Wednesday, July 31
Kindergartners dodge ravenous zombies in Little Monsters red band trailer
Lupita Nyong’o plays a kindergarten teacher protecting her kids from a zombie outbreak in Little Monsters.
It's turning out to be a very good year for zombie comedy. We had Jim Jarmusch's deadpan The Dead Don't Die in June, and the long-awaited Zombieland 2: Double Tap is coming this fall. And now we have the red band trailer for Little Monsters, Australian Director Abe Forsythe's new black comedy that debuted at the Sundance Film Festival earlier this year.
Kindergarten teacher Miss Caroline (Lupita Nyong'o) takes her young charges on a school field trip to Pleasant Valley Farm. Tagging along as a chaperone is Dave (Alexander England), a failed musician whose nephew is in her class. Dave has a romantic interest in Miss Caroline and is chagrined to discover that he has a rival for her affections: a famous children's TV personality, Teddy McGiggle (Josh Gad), who also happens to be at the farm organizing all the planned activities.
But something has gone terribly wrong at a nearby military base, and a zombie outbreak turns the innocent excursion into a bloody fight for survival. Miss Caroline, Dave, and Teddy join forces to make sure the kids don't get eaten—and hopefully aren't traumatized for life by the sight of the ravenous undead.
Read 3 remaining paragraphs | Comments
Big Ol’ LED Wall Looks Cool, Can Draw Over 170 Amps
Building giant LED walls comes with a serious set of challenges. Whether they lie in power, cable routing, or just finding a way to clock out data fast enough for all the pixels, it takes some doing to build a decent sized display. [Phill] wanted a statement piece for the office, so rolled up his sleeves and got to work.
The build uses P5 panels, which we’ve seen used before on a smaller scale. Initial testing was done with a Raspberry Pi 3, which started to run out of grunt when the build reached 28 panels. The refresh rate was slow, and anything with motion looked messy. At that point, a dedicated driver was sourced in order to handle the full 48-panel display. Other challenges involved dealing with the huge power requirements – over 170 amps at 5 volts – and building a frame to hold all the panels securely.
The final product is impressive, standing 2 meters wide and 1.2 meters high. Resolution is 384 x 256. With a Mac Mini running video into the display through the off-the-shelf driver, all manner of content is possible. [Phill] even whipped up a Slack channel for users to send GIFs and text messages to the display. Naturally, we’re sure nobody will take advantage of this functionality.
If you’ve got your own giant LED wall, and you’re dying to tell us about it, make sure you get in touch. Video after the break.
Open Source Smart Display Takes the Long Way Around
Thanks to the relatively low cost of the Raspberry Pi and high resolution LCD screens, “smart displays” have become a favorite project of those looking to clear out their parts bins. Just hook the Pi up to the screen, setup some software, and you’ve got yourself a digital bulletin board for your home that can show your schedule, the weather, etc. Build it into a mirror, and you’ve got yourself at least double Internet points.
But when [John Basista] started planning his own smart display, he decided to take the path less traveled. He’s entered the resulting open source project into the 2019 Hackaday Prize, and we’re very excited to see where it goes from here. Even in these early days he’s already made some great strides, with nary a Raspberry Pi in sight.
[John] has nothing against using the Raspberry Pi for these smart displays, and indeed, it has a number of traits which make it particularly well suited to the task. But the problem for him was that it only supported HDMI, and he had his heart set on using an Embedded DisplayPort (eDP) screen. Namely the Innolux N173HCE-E31, a 17.3 inch IPS LCD designed for laptops.
He tried to find a Linux or Android compatible SBC that featured eDP, but found it to be a challenge. There were some x86 options, but didn’t want to go down that road. Eventually he settled on the Dragonboard 410c, which features a quad-core Qualcomm APQ8016E CPU running at 1.2 GHz and 1GB of RAM. This board didn’t have eDP either, but it did have Display Serial Interface (DSI), which he could convert to eDP with the Texas Instruments SN65DSI86 IC.
From there, he started developing a PCB which would hold the Dragonboard 410c and the SN65DSI86. The board also breaks out I2C and UART so he can connect it to various other sensors and gadgetry down the road, and includes all the necessary power regulation to drive everything. The whole thing fits in the palm of your hand, and judging by the renders [John] has put together, should nestle nicely into the back of the 3D printed enclosure when everything is finished.
There’s still quite a bit left to do on this project, but [John] has plenty of time to tie up the loose ends. Currently there’s little information about the software side of things, but as you can see in the video after the break, it’s now running Android which should make things relatively easy.
Samsung Galaxy Tab S6 packs a Snapdragon 855, in-screen fingerprint reader
-
The Galaxy Tab S6 with keyboard case.
Samsung is still not giving up on the Android tablet market. Today the company announced the Samsung Galaxy Tab S6, its latest high-end tablet, for $649.
The Samsung Tab S6 features a 10.5-inch 2560×1600 OLED display, a 2.84GHz Snapdragon 855, and a 7040mAh battery. The base version has 6GB of RAM and 128GB of storage, with a higher tier of 8GB of RAM and 256GB of storage. For cameras, there's an 8MP front camera, while the rear gets a 13MP main camera and a 5MP wide-angle lens. The device is down to 5.7mm thick and weighs 420 grams. This is Samsung's first-ever tablet with an in-screen fingerprint reader. Interestingly, it's an optical reader instead of the ultrasonic tech that the Galaxy S10 uses.
Somehow, on a 10-inch tablet, Samsung couldn't find room for a headphone jack. Even Apple, which ditched the headphone jack two years ago, still puts a headphone jack on iPads. Samsung is apparently declaring war on the headphone jack with this round of updates—the Galaxy Note 10, launching next week, is expected to dump the headphone jack, too.
Read 4 remaining paragraphs | Comments
BootBasic Fits Your Favorite Language in the Boot Sector
Humans seem to have a need to do things that aren’t practical. Make the biggest ball of twine. Engrave the Declaration of Independence on a grain of rice. We want to make things bigger, smaller, faster, or whatever. That might explain why [nanochess] put out bootBASIC.
The 8088 (or later) assembly code gives you a very restricted BASIC interpreter that you can boot up. That means it has to fit in the 512-byte boot block that the hardware loads to get an operating system running. How restricted? Keep in mind it fits in 512 bytes. Each line can only have 19 characters or less. Backspace works, but doesn’t update the screen. Line numbers range from 1 to 999 and there are only 26 integer variables named a through z that hold 16 bits. All statements are in lower case.
While that’s pretty draconian, it still isn’t bad for less than 1K of space. Not only are the four common math operators available, but they obey standard precedence rules (that is, multiply and divide before add and subtract). You can even use parenthesis.
This isn’t going to replace VisualBasic or anything else, of course. But that really isn’t the point. It looks like [nanochess] is using this to promote a book about developing for the boot sector, but that’s not something everyone needs to know how to do. The readme implies the code comments are only in the book, but we glanced through the code on GitHub and it seemed well commented if you are interested in learning a little assembly language.
If you’d rather do your Basic programming for the Web, that’s easy. Or there’s always QuckBasic.
Review: NOS4A2 is a haunting fable about the steep cost of creative gifts
-
Ashleigh Cummings plays Vic McQueen, a "strong creative" with a gift for finding lost things. [credit: AMC ]
You may have missed AMC's evocative new horror series, NOS4A2, in the jumble of hotly anticipated movies and TV series over the past few months. It's largely flown under the radar in terms of media coverage, but this haunting fable of the high cost of supernatural gifts won over sufficient fans for AMC to already approve a second season—one week before the show's two-part season one finale aired.
(Some spoilers for the novel and series below.)
The series is an adaption of the 2013 award-winning horror novel of the same name by Joe Hill. Hill comes by his horror chops naturally; his dad is some obscure novelist named Stephen King. (Hill also created the fantastic comic book series, Locke and Key, about a mysterious Keyhouse filled with portals to other dimensions that can be opened by various keys. The beleaguered TV adaption project for that series is now with Netflix.)
Read 11 remaining paragraphs | Comments
Maker Spotight: Michael Curry
Name: Michael Curry Home Town: Kansas City, Missouri Makerspace: Hammerspace Workshop Day Job: Consulting Designer – Kansas City Kit Company I provide design, drafting, and product development services from my office located at the local makerspace, Hammerspace Workshop in Kansas City, MO. Check out my Portfolio How did you […]
The post Maker Spotight: Michael Curry appeared first on Make: DIY Projects and Ideas for Makers.
Tiny ThinkPad Plays Tiny Games
[Paul Klinger] can’t seem to get enough of building tiny, amazing gaming rigs, and we love him for that. They combine two of our favorites: miniatures and portable gaming. His newest creation honors the form of the formidable ThinkPad.
Of course it has the red nipple and lid LED—wouldn’t be a ThinkPad without ’em. ThinkTiny’s nipple is a 5-way joystick that plays Snake, Tetris, Lunar Lander, and more on an OLED screen. Like its predecessor the Tiny PC, [Paul] used an ATtiny1614, which (FYI) has a new one-wire UDPI interface. He can easily reprogram it through pogo pin holes built into the case.
There are some nice stylistic details at play here, too. The lid LED is both delivered and diffused by a 2mm grain of fiber-optic cable. And [Paul] printed the cover with a color change to transparent filament to make the Think logo and the charging LEDs shine through. Maneuver your way past the break to see it in action.
If you haven’t leveled up to AVR programming yet, introduce yourself to Arduboy.
Run Your Own Phone to Bring the Dreamcast Back Online
Playing a video game online is almost second nature now. So much so that almost all multiplayer video games have ditched their split-screen multiplayer modes because they assume you’d rather just be alone at your house than hanging out with your friends. This wasn’t always the case though. In the early days of online multiplayer, systems had to rely on dial-up internet before broadband was readily available (and still had split screen if you didn’t even have that). Almost no one uses dial up anymore though, so if you still like playing your old Dreamcast you’re going to have to do some work to get it online again.
Luckily for all of us there’s a Raspberry Pi image to do almost anything now. This project from [Kazade] uses one to mimic a dial-up connection for a Dreamcast so you can connect with other people still playing Quake 20 years later. It’s essentially a network bridge, but you will need some extra hardware because phone lines use a high voltage line that you’ll have to make (or buy) a solution for. Once all the hardware is set up and working, you’ll need to make a few software configuration changes, but it’s a very straightforward project.
Granted, there have been ways of playing Dreamcast games online before, but this new method really streamlines the process and makes it as simple as possible. The Dreamcast was a great system, and there’s an argument to be made that the only reason it wasn’t more popular was that it was just slightly too far ahead of its time.
Thanks to [Rusty] for the tip!
Chiptunes Via USB MIDI With The AY-3-8910
There are many venerable soundchips in the chiptune pantheon, of which the AY-3-8910 is perhaps one of the lesser known. Having not served on active duty for Nintendo or Commodore it’s somewhat unloved in the USA, but it made its name in a variety of arcade and pinball machines and has quite a European following due to its appearance in machines bearing the Amstrad and Sinclair names. [TheSpodShed] decided to whip up a USB MIDI interface for the chip, with the help of the Arduino Pro Micro.
The Arduino Pro Micro is a Sparkfun creation, using the ATmega32U4 microcontroller. Its USB MIDI functionality makes it a perfect candidate for such a build, and it also packs enough digital IO to run the AY-3-8910, with 13 lines required to get things going. [TheSpodShed] whipped up the project on protoboard, with only a few passives needed along with the sound chip and Arduino.
The Arduino code was written with an eye to making the most of the chip’s limited polyphony. The synth prioritises the most recent received notes, while also aiming to keep the highest and lowest of the currently requested notes still playing where possible. This gives the synth the best chance of keeping the expected bass and melody intact when playing a wide variety of MIDI content.
It’s a tidy build, and one that shows some love for a soundchip some have forgotten. Of course, it’s not the only option – we’ve also seen the SAM2695 and YM2612 given the same treatment. Video after the break.
Four Years Of Learning ESP8266 Development Went Into This Guide
The ESP8266 is a great processor for a lot of projects needing a small microcontroller and Wi-Fi, all for a reasonable price and in some pretty small form factors. [Simon] used one to build a garage door opener. This project isn’t really about his garage door opener based on a cheap WiFi-enabled chip, though. It’s about the four year process he went through to learn how to develop on these chips, and luckily he wrote a guide that anyone can use so that we don’t make the same mistakes he did.
The guide starts by suggesting which specific products are the easiest to use, and then moves on to some “best practices” for using these devices (with which we can’t argue much), before going through some example code. The most valuable parts of this guide especially for anyone starting out with these chips are the section which details how to get the web server up and running, and the best practices for developing HTML code for the tiny device (hint: develop somewhere else).
[Simon] also makes extensive use of the Chrome developers tools when building the HTML for the ESP. This is a handy trick even outside of ESP8266 development which might be useful for other tasks as well. Even though most of the guide won’t be new to anyone with experience with these boards, there are a few gems within it like this one that might help in other unrelated projects. It’s a good read and goes into a lot of detail about more than just the ESP chips. If you just want to open your garage door, though, you have lots of options.
Tuesday, July 30
Preserving Historic NASA Display Technology
When [Patrick Hickey] spent a tidy sum on eBay to purchase a pair of seven-segment displays used in the Launch Control Center at Kennedy Space Center during the Apollo program, he could have just put them up on a shelf. It’s certainly what most people would have done. Instead, he’s decided to study and document their design with the hope of eventually creating 3D replicas of these unique pieces of NASA history.
With a half century now separating us from the Moon landing, it’s more important than ever to preserve the incredible technology that NASA used during mankind’s greatest adventure. Legitimate Apollo-era hardware is fairly scarce on the open market, and certainly not cheap. As [Patrick] explains on the Hackaday.io page for this project, being able to 3D print accurate replicas of these displays is perhaps the best way we can be sure they won’t be lost to history.
But more than that, he also wants others to be able to see them in operation and perhaps even use them in their own projects. So that means coming up with modern electronics that stand-in for the 60s era hardware which originally powered them.
Since [Patrick] doesn’t have access to whatever (likely incandescent) lighting source these displays used originally, his electronics are strictly functional rather than being an attempt at a historic recreation. But we have to say, the effect looks fantastic regardless.
Currently, [Patrick] is putting most of his efforts on the smaller of the two displays that he calls “Type A”. The chunk of milled aluminum with integrated cooling fins has a relatively simple shape that should lend itself to replication through 3D scanning or even just a pair of calipers. He’s also put together a proof of concept for how he intends to light the display with 5mm LEDs on a carefully trimmed bit of protoboard, which he plans on eventually refining to reduce the number of wires used.
One aspect he’s still a little unsure of is how best to replicate the front mask. It appears to be made of etched metal with an integrated fiberglass diffuser, and while he’s already come up with a few possible ways to create a similar front panel for his 3D printed version, he’s certainly open to suggestions from the community.
This isn’t the first time we’ve seen a dedicated individual use 3D printing to recreate a rare and expensive object. While the purists will say that an extruded plastic version doesn’t compare to the real thing, we think it’s certainly better than letting technology like this fade into obscurity.
Nissan’s bigger-battery BEV—the 2019 Leaf Plus review
-
The Nissan Leaf Plus starts at $36,550. [credit: Jonathan Gitlin ]
Electric vehicles are the future of driving, even if it might take us a few more decades to get there. They were also the past of driving; early automobiles as often as not ran on battery power, and even Henry Ford's wife eschewed one of his creations for a more sophisticated European-made EV. It's just that right now, EVs aren't really the present of driving. I'm sure global EV sales will set another new record for year-on-year growth, but 2018's banner year still represented just 2.1 percent of global light-passenger-vehicle sales.
Of course, people can only buy electric cars if someone builds them. And it's taken a combination of draconian European carbon fines and diesel's utter disgrace for the world's biggest car makers to truly catch that religion. But there were some early converts. Like the charismatic car company CEO who bet big on mass-produced EVs and lithium-ion batteries, earning a description from Wired as "either a brilliant visionary or crazy as a loon."
No, not that one, although I did discover that quote reading Edward Niedermeyer's forthcoming book on Tesla. I am referring to Carlos Ghosn, former CEO of Nissan and Renault, who wanted his companies building a half-million EVs a year—back in 2013. Obviously, that plan didn't quite work out, but Nissan sold almost 300,000 Leafs (Leaves?) by the time the second-generation Leaf went on sale in 2017.
Read 10 remaining paragraphs | Comments
Pick and Place Robot Built with Fischertechnik
We’d be entirely wrong to think that Fichertechnik is just a toy for kids. It’s also perfect for prototyping the control system of robots. [davidatfsg]’s recent entry in the Hackaday Prize, Delta Robot, shows how complex robotics can be implemented without the hardship of having to drill, cut, bolt together or weld components. The added bonus is that the machine can be completely disassembled non-destructively and rebuilt with a new and better design with little or no waste.
The project uses inverse kinematics running on an Arduino Mega to pick coloured objects off a moving conveyor belt and drop them in their respective bins. There’s also also an optical encoder for regulating the speed of the conveyor and a laser light beam for sensing that the object on the conveyor has reached the correct position to be picked.
Not every component is ‘off the shelf’. [davidatfsg] 3D printed a simple nozzle for the actual ‘pick’ and the vacuum required was generated by the clever use of a pair of pneumatic cylinders and solenoid operated air valves.
We’re pretty sure that this will not be the last project on Hackaday that uses Fischertechnik components and it’s the second one that [davidatfsg] has concocted. Videos of the machine working after the break!
Putting the PS4’s 100 million sales in context
-
Fig. 1: The PS4 is the fastest home console to reach the 100 million sales milestone, though the Nintendo DS was a bit faster.
Here at Ars, we haven't been putting a lot of regular time and effort lately into updating Ars readers on the continuing sales battle between Sony's PlayStation 4 and Microsoft's Xbox One. It has been abundantly clear for a while now that Sony's system is heavily outpacing Microsoft's in worldwide sales. In fact, the PS4 is also still outselling the Nintendo Switch on an annual basis despite being many years older.
But with Sony announcing last night that the PS4 had passed the 100 million sales mark in under six years, we thought it was worth putting that nine-figure milestone into some context. Here are some comparisons to help your mind grasp how significant this sales level (and pace) really is.
- 67 months: Time for the PlayStation 4 to sell 100 million units worldwide. (Source)
- 69 months: Time for the PlayStation 2 to sell 100 million units worldwide. (Source)
- 79 months: Time for the Wii to sell 100 million units worldwide. (Source)
- 113 months: Time for the original PlayStation to sell 100 million units worldwide. (Source)
Read 4 remaining paragraphs | Comments
The Lighthouse channels the spirit of Alfred Hitchcock in its first trailer
Willem Dafoe and Robert Pattinson star in A24’s Cannes favorite,The Lighthouse.
A24 just keeps churning out smartly intriguing, thought-provoking films, and today the studio dropped the first trailer for its latest offering in the horror genre, The Lighthouse. At first glance, what sets this apart is the choice to shoot entirely on 35mmm black-and-white film—better to evoke a bygone age.
Set in 1890, Director Robert Eggers' vision was inspired by a real-life 1801 tragedy involving two Welsh lighthouse keepers trapped in a storm, as well as classic tales by Herman Melville, H.P. Lovecraft, and Algernon Blackwood. It's kind of a ghost story, featuring two lighthouse keepers (Willem Dafoe and Robert Pattinson) on a remote and mysterious New England island, and both gradually go mad from the isolation.
The Lighthouse made its debut at the Cannes Film Festival earlier this year to rave reviews, earning a best movie honor from the International Federation of Film Critics—a first for A24. Eggers described the film to Deadline Hollywood as “something a little weirder” than his 2015 breakout film, The Witch, calling it “more dreadful than horror.”
Read 4 remaining paragraphs | Comments
Vintage Computer Festival West is Almost Here
If you’ve got an interest in technology, a penchant for that particular shade of yellowed plastic, and happen to be located in the California area, then we’ve got the event for you. The Vintage Computer Festival West is happening this weekend, August 3rd and 4th, at the Computer History Museum in Mountain View, California.
The Vintage Computer Festival offers a truly unique experience for anyone with a passion for all the silicon that’s come before. Where else could you sit in on a roundtable of early Apple employees discussing the bevy of authentic ultra-rare Apple I computers that will be on display, or get up close and personal with a restored Apollo Guidance Computer? If you really want to dive in on the deep end, Hackaday’s own Bill Herd will be in attendance giving his lecture about the effects of heat and time on the internal components of decades-old pieces of hardware.
Still skeptical? Perhaps you’ll get a kick out of the exhibit that celebrates more than two decades of Quake by hosting a LAN game where the classic game is running on less common platforms like the RS/6000 series or the Sun Ulta. If you’re interested in seeing modern reconstructions of classic technology, there will be plenty of that on display as well. Eric Schlaepfer will be showing off his transistor-scale replica of the iconic 6502 microprocessor, and you won’t want to miss the Cactus in all its rainbow colored toggle switch and blinkenlight glory.
Of course, if you’re in the market for your very own piece of computing history, there’s no better place to be. The consignment area gives showgoers a chance to buy and sell all manners of vintage and unique hardware, harking back to the days where the best way to get your hands on a computer (or the parts to build one) was by attending a dedicated event. Plus, no shipping fees!
Put simply, there really is something for everyone at the Vintage Computer Festival. Even if you weren’t around to experience Apple II or Commodore 64 in their prime, these events are a rare opportunity to learn about the early days of a technology that today we all take for granted. Have you ever wondered how programs were entered into those early computers with nothing more than a bank of toggle switches and an array of LEDs? One of the passionate exhibitors at VCF will be more than happy to walk you through the process.
At the end of the day, preserving this technology and sharing it with future generations is really what it’s all about. Just as in previous years, Hackaday is proud to sponsor the Vintage Computer Festival and further their goal of ensuring this incredible shared heritage isn’t lost.
Driving a Big RC Car On The Ceiling
RC cars are a great way to have fun hooning around. There’s plenty of laughs to be had racing your friends in the local grocery store carpark, ideally after hours. [Ivan Miranda] wanted to go in a different direction, however – and that direction was up. (Video embedded after the break.)
There are existing toys that can pull off a wall-riding feat, but they’re normally on a fairly small scale. [Ivan] wanted to go big, and so outfitted some seriously powerful brushless fans on to his 1/8th Rattler buggy from Hobbyking. After initial failure, a smaller scale model was successfully built and tested, before it was realised the full-sized build had the propellers on backwards.
With this oversight fixed, the car was able to drive on the ceiling, albeit in the limited space between the roof beams. It was somewhat less viable on the wall, struggling to stay stuck and having issues with suspension flex.
Overall, it’s a great application of mass brushless power to fight gravity – the same principle behind the multirotors we all love so much. [Ivan]’s put the same trick to use for getting around on a skateboard, too. Video after the break.
C++20 Is Feature Complete; Here’s What Changes Are Coming
If you have an opinion about C++, chances are you either love it for its extensiveness and versatility, or you hate it for its bloated complexity and would rather stick to alternative languages on both sides of the spectrum. Either way, here’s your chance to form a new opinion about the language. The C++ standard committee has recently gathered to work on finalizing the language standard’s newest revision, C++20, deciding on all the new features that will come to C++’s next major release.
After C++17, this will be the sixth revision of the C++ standard, and the language has come a long way from its “being a superset of C” times. Frankly, when it comes to loving or hating the language, I haven’t fully made up my own mind about it yet. My biggest issue with it is that “programming in C++” can just mean so many different things nowadays, from a trivial “C with classes” style to writing code that will make Perl look like prose. C++ has become such a feature-rich and downright overwhelming language over all these years, and with all the additions coming with C++20, things won’t get easier. Although, they also won’t get harder. Well, at least not necessarily. I guess? Well, it’s complex, but that’s simply the nature of the language.
Anyway, the list of new features is long, combining all the specification proposals is even longer, and each and every one of these additions could fill its own, full-blown article. But to get a rough idea about what’s going to come to C++ next year, let’s have a condensed look at some of these major new features, changes, and additions that will await us in C++20. From better type checking and compiler errors messages to Python-like string handling and plans to replace the #include system, there’s a lot at play here!
Making Things Safer
As a language, being more liberal and less restrictive on implementation details provides great flexibility for developers — along with a lot of potential for misunderstandings that are bound to result in bugs somewhere further down the road. It is to this day the biggest asset and weakness of C, and C++ still has enough similarities in its roots to follow along with it. Restrictions can surely help here, but adding restrictions tends to be an unpopular option. The good thing is, C++ has compromises in place that leave the flexibility on the language level, and adds the restrictions at the developer’s own discretion.
Compiler Advisory: Explicit Constants
Back in C++11, the constexpr keyword was introduced as an addition to a regular const declaration, defining a constant expression that can be evaluated at compile time. This opens up plenty of optimization opportunities for the compiler, but also makes it possible to declare that, for example, a function will return a constant value. That helps to more clearly show a function’s intent, avoiding some potential headaches in the future. Take the following example:
int foo() {
return 123;
}
constexpr int bar() {
return 123;
}
const int first = foo();
const int second = bar();
While there is technically no difference between these two functions, and either one will return a constant value that will be valid to assign to a const variable, bar() will make this fact explicitly clear. In the case of foo(), it’s really more of a coincidental side effect, and without full context, it is not obvious that the function’s return value is supposed to be a constant. Using constexpr eliminates any doubt here and avoids possible accidental side effects, which will make the code more stable in the long run.
Having already been in place for a while, constexpr has seen a few improvements over the years, and will see some more with C++20, especially in terms of removing previously existing limitations on their usage. Most the new standard allows virtual constexpr functions, developers can use try / catch inside constexpr (provided no exceptions are thrown from within), and it’s possible to change members inside of a union.
On top of that, both std::string and std::vector as well as a bunch of other previously missing places in the standard library will fully utilize constexpr. Oh, and if you want to check if a piece of code is actually executed within a constant evaluation, you will be able to do so using std::is_constant_evaluated() which returns a boolean value accordingly.
Note that constexpr code states that it can be evaluated at compile time and is therefore a valid constant expression, but it doesn’t necessarily have to, nor is it guaranteed that the evaluation will happen at compile time, but could be postponed to run time. This is mainly relevant for compiler optimization though and doesn’t affect the program’s behavior, but also shows that constexpr is primarily an intention marker.
constexpr int foo(int factor) {
return 123 * factor;
}
const int const_factor = 10;
int non_const_factor = 20;
const int first = foo(const_factor);
const int second = foo(non_const_factor);
Here, first will be evaluated at compile time as all expressions and values involved are constants and as such known at compile time, while second will be evaluated at run time since non_const_factor itself is not a constant. It doesn’t change the fact though that foo() is still going to return a constant value, the compiler just can’t be sure yet which exact value that may be. To make sure the compiler will know the value, C++20 introduces the consteval keyword to declare a function as an immediate function. Declaring foo() as consteval instead of constexpr will now indeed cause an error. In fact, immediate functions are really only known at compile time, and as a consequence this turns the consteval functions into an alternative for macro functions.
At the other end of the constant expression verification strictness is the new constinit keyword that is mainly telling the compiler that an object will be statically initialized with a constant value. If you are familiar with the static initialization order fiasco, this is an attempt to solve the issue.
But constant expressions aren’t the only C++20 changes aimed at improving compile time validation, and the stability that comes with it.
The Concept Of Concepts
While technically not a completely new thing, Concepts have graduated from being an experimental feature to a full-fledged part of the language standard, allowing the addition of semantic constraints to templates, and ultimately making generic programming a hint more specific.
Somewhat related to type traits, Concepts make sure that data used within a template fulfill a specified set of criteria, and verifies this at the beginning of the compilation process. So as an example, instead of checking that an object is_integral, an object of type Integral is used. As a result, the compiler can provide a short and meaningful error message if the defined requirement of a concept isn’t met, instead of dumping walls of errors and warnings from somewhere deep within the template code itself that won’t make much sense without digging further into that code.
Apart from letting the compiler know what data is needed, it also shows rather clearly to other developers what data is expected, helping to avoid error messages in the first place, and avoids misunderstandings that lead to bugs later on. Going the other direction, Concepts can also be used to constrain the return type of template functions, limiting variables to a Concept rather than a generic auto type, which can be considered at C++’s void * return type.
Some basic Concepts will be provided in the standard library, and if you don’t want to wait for updated compilers, GCC has the experimental Concepts implemented since version 6 and you can enable them with the -fconcepts command line parameter. Note that in the initial draft and current reference documentation, Concept names were defined using CamelCase, but they will be changed to snake_case to preserve consistency with all other standard identifiers.
Ranges Are The New Iterators
Ranges are essentially iterators that cover a sequence of values in collections such as lists or vectors, but instead of constantly dragging the beginning and end of the iterator around, ranges just keep them around internally.
Just as Concepts, Ranges have also moved from experimental state to the language standard in C++20, which isn’t much of a coincidence as Ranges depend on Concepts and uses them to improve the old iterator handling by making it possible to add constraints to the handled values, with the same benefits. On top of constraining value types, Ranges introduce Views as a special form of a range, which allows data manipulation or filtering on a range, returning a modified version of the initial range’s data as yet another range. This allows them to be chained together. Say you have a vector of integers and you want to retrieve all even values in their squared form — ranges and views can get you there.
With all of these changes, the compiler will be of a lot more assistance for type checking and will present more useful error messages.
String Formatting
Speaking of error messages, or well, output in general, following the proposal of its author the libfmt library will be integrated into the language standard as std::format. Essentially this provides Python’s string formatting functionality! Compared to the whole clumsiness of the cout shifting business, and the fact that using printf() in the context of C++ just feeling somewhat wrong, this is definitely a welcomed addition.
While the Python style formatting offers pretty much the same functionality as printf(), just in a different format string syntax, it eliminates a few redundancies and offers some useful additions, such as binary integer representation, and centered output with or without fill characters. However, the biggest advantage is the possibility to define formatting rules for custom types, on the surface this is like Python’s __str__() or Java’s toString() methods, but it also adds custom formatting types along the way.
Take strftime() as example — albeit it this is a C function, which behaves as snprintf(), the difference is that it defines custom, time-specific conversion characters for its format string, and expects struct tm as argument. With the right implementation, std::format could be extended to behave just like that, which is in fact what the upcoming addition to the std::chrono library is going to do.
Source Location
While we’re on the subject of nicely formatting in convenient ways, another experimental feature coming to C++20 is the source_location functionality, providing convenient access to the file name, line number, or function name from the current call context. In combination with std::format, a prime candidate for implementing a custom logging function, and practically a modern alternative to preprocessor macros like __FILE__ and __LINE__.
Modules
It appears that slowly eliminating use of the preprocessor is a long-term goal in the future of C++, with consteval essentially replacing macro functions, source_location obsoleting one of the most commonly used macros, and on top of all that: modules, a new way to split up source code that aims to eventually replace the whole #include system.
While some say it’s long overdue, others see the addition of modules at this point rather critical, and some developers have stated their concerns about the current state. Whatever your own opinion is on the subject, it’s safe that say that this is a major change to the whole essence of the language, but at the same time a complex enough undertaking that won’t just happen over night. Time will tell where modules will actually end up. If you’re curious and want to have a look at it already, both GCC and Clang already have module support to some extent.
But wait, there is more!
Everything Else
The list just goes on, with Coroutines as one more major feature that will be added to C++20.
As for all the rest, there will be
- a new synchronization library
- cooperatively interruptible joining interrupts
- the spaceship operator
<=>for three-way comparisons using enumto get rid of some namespace separation noise- a bunch of additions to lambda expressions
- some partial deprecation of
volatile
Don’t worry though, the parts that really matter to be volatile won’t change.
So all in all, a lot is coming to C++, and some features are sure worthy to be excited about.
Of course, some of these new features and extensions have been around in other languages for ages, if not even from the beginning. It’s interesting to see though how some of these languages that were once influenced by C++ are now influencing the very future of C++ itself.
Maker Spotlight: Anne Quinn
Name: Anne Quinn Home: Overland Park, KS. Makerspace: Hammerspace Workshop in Kansas City, MO. Day Job: Digital machinist & graphic artist How did you get started in making? I have been a creative for as long as I can remember. I went to UW-Stout for industrial design and UWEC for […]
The post Maker Spotlight: Anne Quinn appeared first on Make: DIY Projects and Ideas for Makers.
Etch-A-Selfie
Taking a selfie before the modern smartphone era was a true endeavor. Flip phones didn’t have forward-facing cameras, and if you want to go really far back to the days of film cameras, you needed to set a timer on your camera and hope, or get a physical remote shutter. You could also try and create a self portrait on an Etch a Sketch, too, but this would take a lot of time and artistic skill. Luckily in the modern world, we can bring some of this old technology into the future and add a robot to create interesting retro selfies – without needing to be an artist.
The device from [im-pro] attaches two servos to the Etch a Sketch knobs. This isn’t really a new idea in itself, but the device also includes a front-facing camera, taking advantage of particularly inexpensive ESP32 Camera modules. Combining the camera features with [Bart Dring]’s ESP32 Grbl port is a winner. Check the code in [im-pro]’s GitHub.
Once the picture is taken, the ESP32 at the heart of the build handles the image processing and then drawing the image on the Etch a Sketch. The robot needs a black and white image to draw, and an algorithm for doing it without “lifting” the drawing tool, and these tasks stretch the capabilities of such a small processor. It takes some time to work, but in the end the results speak for themselves.
The final project is definitely worth looking for, if not for the interesting ESP32-controlled robot than for the image processing algorithim implementation. The ESP32 is a truly versatile platform, though, and is useful for building almost anything.
Apple Lightning Video Adaptors Run iOS, Dynamically Loaded
Apple has for a very long time been a company that ploughs its own furrow when it comes to peripherals, with expensive proprietary hardware being the order of the day over successive generations of its products. One of its current line of proprietary interfaces is the Lightning connector, best thought of as an Apple-only take on the same ideas that the rest of the world knows as USB-C. There are a whole host of white dangly peripherals that can be hung from your iDevice’s Lightning port, including a pair of display adaptors that allow them to drive an HDMI or VGA monitor. [Lisa Braun] has subjected one that had failed to a teardown, and her analysis gives some insight into the way Apple creates its peripherals.
Where you might expect these to contain mostly the equivalent of a graphics card, in fact they have a fully-fledged SoC of their own that runs its own OS with the same Darwin kernel as its host. Unexpectedly this is not held upon the adapter itself, instead it is shipped with iOS and loaded dynamically. Thus the file containing it can be retrieved from iOS and unpacked, leading to some interesting analysis. In a fascinating twist for those of us unused to Lightning’s internals, it’s revealed that the device can be driven from a USB port with the appropriate cobbled-together adapter, allowing a full-size MacOS device to interrogate it. This many not be news to readers with a long memory though, we’ve told you in the past about reverse engineering the Lightning connector.
Dreamcast Gets A Plug-n-Play Hard Drive Mod
The Dreamcast was a proud moment for Sega, at least initially, being the first console to launch of a new generation. Unfortunately this didn’t translate into massive sales, and the plug was pulled far earlier than expected. The console retains a dedicated fanbase to this day however, who continue to tinker with the hardware. [DreamcastChannel] is one of them, and put together a nifty plug-and-play hard drive mod.
The mod is based on earlier work, which consisted of manually soldering the 44 lines of an IDE cable on to the main Dreamcast motherboard. This allowed an IDE hard drive to be neatly mounted inside the shell, but [DreamcastChannel] knew it was possible to do better.
Starting from scratch, the GDROM optical drive assembly is gutted, leaving just its metal case and PCB. The IDE cable for the hard disk is then soldered to the pads on the PCB. A 3D printed mount is used to fix the hard drive to the metal case. This allows the entire assembly to slot neatly into the Dreamcast, using the GDROM’s original connector.
It’s a hack that makes putting a hard drive into the Dreamcast neat and tidy. Combined with a hacked BIOS and Dreamshell, it makes playing backup games a breeze. We’ve seen plenty of Dreamcast hacks before, too – the VMU is often a key candidate for attention. Video after the break.
[Thanks to Dale Gribble for the tip!]
Where The Work Is Really Done – Casual Profiling
Once a program has been debugged and works properly, it might be time to start optimizing it. A common way of doing this is a method called profiling – watching a program execute and counting the amount of computing time each step in the program takes. This is all well and good for most programs, but gets complicated when processes execute on more than one core. A profiler may count time spent waiting in a program for a process in another core to finish, giving meaningless results. To solve this problem, a method called casual profiling was developed.
In casual profiling, markers are placed in the code and the profiler can measure how fast the program gets to these markers. Since multiple cores are involved, and the profiler can’t speed up the rest of the program, it actually slows everything else down and measures the markers in order to simulate an increase in speed. [Daniel Morsig] took this idea and implemented it in Go, with an example used to demonstrate its effectiveness speeding up a single process by 95%, resulting in a 22% increase in the entire program. Using a regular profiler only counted a 3% increase, which was not as informative as the casual profiler’s 22% measurement.
We got this tip from [Greg Kennedy] who notes that he hasn’t seen much use of casual profiling outside of the academic world, but we agree that there is likely some usefulness to this method of keeping track of a multi-threaded program’s efficiency. If you know of any other ways of solving this problem, or have seen causal profiling in use in the wild, let us know in the comments below.
Header image: Alan Lorenzo [CC BY-SA 3.0].
A Simple Way To Analyze Guitar Pickups
To the uninitiated an electric guitar seems fairly simple: you pluck a string and the electronics send the corresponding audio signal on the 6.3 mm jack output, all ready for for the amplifier to work its magic. Much of what makes a guitar like that sound good depends on the pickups, however. These are the devices which are placed between the guitar body and the strings. Depending on the guitar there can be one, two, or more of them, of varying types and configurations.
As a Gibson fan who upon getting introduced to a Fender Telecaster just had to replace its pickups with humbucking types, [Ken Willmott] found himself thrown into the wonderful world of pickup design and characterization. After two years of working through a number of designs and approaches, he eventually settled on a preamplifier design featuring a JFET opamp (LT1058) on a custom PCB which amplifies the pickup response from a test signal, acting as a front end signal conditioner.
The test signal is induced by an electromagnetic coil placed near the pickup-under-test (PUT), with this signal generated by the software on the PC – output via the audio card – or by a signal generator . The effect is similar to that of a metal string moving near the pickup while it’s generating its own EM field. The signal produced by the pickup is then amplified by the custom circuit, where it’s then fed back into the software for characterizing.
The take-away from this is that similarly to devices such as speakers, pickups will respond differently to specific frequencies due to their construction. This is why an original Fender Telecaster sounds so different from a standard Stratocaster model, and why each brand has their own sound courtesy of their preferred pickups. With a test setup such as what [Ken] has made one can figure out what a pickup will sound like without even installing it.
Monday, July 29
Punch The World With A Raspberry Pi
Robots have certainly made the world a better place. Virtually everything from automobile assembly to food production uses a robot at some point in the process, not to mention those robots that can clean your house or make your morning coffee. But not every robot needs such a productive purpose. This one allows you to punch the world, which while not producing as much physical value as a welding robot in an assembly line might, certainly seems to have some therapeutic effects at least.
The IoT Planet Puncher comes to us from [8BitsAndAByte] who build lots of different things of equally dubious function. This one allows us to release our frustration on the world by punching it (or rather, a small model of it). A small painted sphere sits in front of a 3D-printed boxing glove mounted on a linear actuator. The linear actuator is driven by a Raspberry Pi. The Pi’s job doesn’t end there, though, as the project also uses a Pi camera to take video of the globe and serve it on a webpage through which anyone can control the punching glove.
While not immediately useful, we certainly had fun punching it a few times, and once a mysterious hand entered the shot to make adjustments to the system as well. Projects like this are good fun, and sometimes you just need to build something, even if it’s goofy, because the urge strikes you.
The Bluetooth LCD Sniffer You Didn’t Know You Needed
At one time or another, we’ve all suffered through working with a piece of equipment that didn’t feature a way to export its data to another device. Whether it was just too old to offer such niceties, or the manufacturer locked the capability behind some upgrade, the pain of staring at digits ticking over on a glowing LCD display and wishing there was a practical way to scrape what our eyes were seeing is well known to hackers.
That was precisely the inspiration for DoMSnif, the dot matrix LCD sniffer that [Blecky] has been working on. Originally the project started as a way to record the temperature of his BRTRO-420 reflow oven, but realizing that such a device could have widespread appeal to other hardware hackers, he’s rightfully decided to enter it into the 2019 Hackaday Prize. If perfected, it could be an excellent way to bolt data capture capabilities to your older devices.
The first phase of this project was figuring out how to capture and parse the signals going into the device’s KS0108 LCD. Getting the data was certainly easy enough, he just had to hook a logic analyzer up between the display and the main board of the device. Of course, figuring out what it all means is a different story.
After running the oven for a bit with the analyzer recording, [Blecky] had more than enough data to get started on decoding it. Luckily, the layout of this fairly common 128×64 pixel display is well documented and easy enough to understand. With a little work, he was able to create a tool that would import the captured data and display it on a virtual LCD.
Unfortunately, the Bluetooth part is where things get tricky. Ultimately, [Blecky] wants to ditch the logic analyzer and use a Adafruit Feather nRF52 Bluefruit to capture the signals going to the LCD and pipe them to a waiting device over Bluetooth. But his testing has found that the nRF52’s radio is simply too slow. The display is receiving data every 14us, but it takes the radio at least 50us to send a packet.
[Blecky] is looking at ways around this problem, and we’re confident he’ll crack it. The solution could be in buffering and compressing the data before sending it out, though you’d lose the ability to monitor the display in real-time. Even if he has to abandon the Bluetooth aspect entirely and make the device wired, we still think there would be a market for an easy to use hardware and software solution for scraping LCD data.
Google announces the Pixel 4 will have FaceID, radar-powered gestures
-
Google's new diagram of the Pixel 4. There's FaceID and Soli technology in there.
After showing off the back of the Pixel 4 in June, Google is again taking the unprecedented step of publicly detailing an unreleased smartphone. The newest post on the company blog is all about the Pixel 4's big top bezel and the tech goodies contained within.
First, Google confirms the earlier rumors from 9to5Google that the device will integrate Project Soli technology:
Pixel 4 will be the first device with Soli, powering our new Motion Sense features to allow you to skip songs, snooze alarms, and silence phone calls, just by waving your hand. These capabilities are just the start, and just as Pixels get better over time, Motion Sense will evolve as well. Motion Sense will be available in select Pixel countries.
Soli, or "Motion Sense" as it's being called in the Pixel 4, is powered by radar. Google's Advanced Technology and Projects team (ATAP) has been working on shrinking down radar into a tiny chip for the last five years. As originally pitched, Soli was capable of detecting a number of fine hand gestures, like tapping your thumb and index finger together for a virtual button press or rubbing the two fingers together to scroll or turn a virtual dial. Google's old Soli YouTube video claims the technology is capable of tracking "sub-millimeter motions at high speed and accuracy," but in this first consumer device, the video shows waving your entire hand across the entire face of the phone to skip music. Gestures like this have been done before on Samsung and Motorola phones with cameras and other optical sensors, and they were not well received enough to be carried forward to future devices.
Read 4 remaining paragraphs | Comments
Hands-On: AND!XOR DEF CON 27 Badge Ditches Bender, Adopts Light Pipes
The newest offering from the AND!XOR team is out and it delivered exactly what hardware badges were missing: light pipes. No joke, the DEF CON 27 edition AND!XOR badge will be most recognizable because of two arcs of light pipe material blinging RGB goodness in three dimensions. But if you can peel your eyes away from that oddity there’s a lot to love about the new design.
A Departure from Bender
Is this a Bender badge? Followers in the cult of #Badgelife will remember that the Bender character from the smash show Futurama has been the official mascot for the AND!XOR team since they began making badges. This badge goes away from that aesthetic and the design achieves a new depth with a gas-mask laden, hoodie-wearing character more reminiscent of Fallout.
Yes, there’s a snappy RGB matrix in the shape of goggles, but it is the art and how it is treated on this board that really catches my eye. This badge looks fantastic even if it’s not switched on. The art is by Kevin Pentecost, a fan of the team who gave them the illustration during last year’s DEF CON.
The familiar PCB color palette of black, white, and gold is at work here, but it’s easy to mistake how it’s put to use. In this case the white is the solder mask, indicated by the exposed gold on either side of the goggles which has white reflection marks on it. The black silkscreen is put to work as a very fine matrix of dots on the hoodie, giving it both an interesting hue to the eye, and a texture under your fingers. Both have a glossy, picture-perfect finish.
But look closely and you’ll see a new trick at work: stickers. The two canisters for the gas mask are stickers whose finish makes it easy to use the capacitive touch scroll wheels built into the board underneath. At the same time, this brings glow-in-the-dark phosphorescent material to the badge.
All past version of AND!XOR badges have included a screen, either OLED or LCD. This one moves away from that in favor of the RGB LED matrix. I most closely associate the goggle layout with the DC Furs badge from 2018. It was a great idea then and it’s a great idea now. Layout breaks up the monotony of a rectangle for an obvious reason, yet still allows scrolling characters as you would with a drab LED sign. Where you could have had a 7×17 matrix, you lose just 17 LEDs to the artistic shape for a total of 102 pixels. It’s the best of both worlds. I don’t miss screens at all here — how can a badge compete with what’s on your smartphone? This competes in a way no smartphone can begin to imagine.
There are two things I don’t like about the front of the badge: the add-on connector and the Rigado module, both near the top of the board interrupt the beautiful design of the rest of the board. There’s an easy solution for that: cover them up with an add-on. AND!XOR sent me all three modules they’ve been involved with this year, and that’s one of the most interesting developments this year.
When Add-Ons Outgrown Being Dependent on a Badge
Kudos to Hyr0n who stopped calling these “Shitty Add-Ons” and started calling them “Superior Add-Ons”. They went all-in on the designs and what we’re actually talking about are stand-alone mini-badges that happen to be compatible with plugging into other badges.
The team sent me all three add-ons. There’s the basic bender, the Audio Reactive SAO (rev 6), and the Doom SAO (rev 1) from AND!XOR’s newest team member, Parker Dillman. (You likely know Parker from the Macrofab podcast which is part of his day job.) All three have microcontrollers on board running the show, while offering access to the outside world through the I2C pins of the 3×2 header that is the SAO V1.69bis standard.
Bender does a great job of returning the team’s mascot and supplying classic bling of their first ever badge. At the same time, there’s a hidden serial output. If only you had something to read that output. Hey, you’re in luck! The AND!XOR DC27 badge itself is a hardware hacking tool that can sniff serial (I’ll get to that in a minute). Actually, the Doom SAO could do it too. In addition to returning a screen to the badge, the Doom guy SAO has a serial sniffer built in that can read the output of the Bender add-on. The third add-on has an electret mic and flashes its LED based on ambient noise.
A Lap Around the Hardware
Let’s take a step back and marvel at what we can do with a handful of ICs and very few passives. Driving the system is a Rigado BMD-340 module which is a familiar feature of the team’s 2017 badge. It runs an NRF52840 core and provides wireless connectivity for the botnet game played between these and other badges at the conference.
The bling is handled by an ISSI chip along with the help of five resistor networks. This year it’s the IS31FL3741. The routing of this display contains hidden beauty for those who look really closely. User for the badge input is handled by capacitive touch using the Azoteq IQS333 to monitor two scroll wheels and the center pad of the DC27 design shown here. All of this is powered by just two AA batteries thanks to the Skyworks boost converter (AAT1217-3.3).
This badge, and the Doom SAO, are pulling us into the 21st century with the use of USB-C connectivity. The tried and true LM1117 regulates incoming power from that connection. A beefy FTDI FT2232H makes two separate USARTs available for this board. I mistakenly tried out ttyUSB0 for my serial connection out of the gate and got a fat nothing-burger. That’s because the Alternate Reality Game is on USB1, the USB0 connection is for the in-built hacking tools.
I’m not entirely sure what I think of the light pipes on this badge. It’s certainly a useful trick to keep in mind for future designs. The plastic receptacles snap onto the board through two small holes each. Straddling an RGB LED on the face of the board, these provide a fixture for the flexible light-pipe material. As you can see in the image a the top of the article, they do a good job of diffusing some light out of the sidewalls of the tube, and if you look into the end of the pipe, the light emission is very strong.
The Lulz Lurk Inside
I like seeing consideration given to making these badges worth keeping around after the conference. (Who am I kidding, they’re works of art and everyone keeps them around.) For the DC27 badge, AND!XOR spent time making as much use out of the FTDI chip as possible and ended up with a multi-tool for hardware hacking that speaks serial, I2C, SPI, and even JTAG via OpenOCD.
Don’t want to deal with hardware protocols? You can bang your head against the digital wall trying to solve the Alternate Reality Game instead. Think Zork, but waaaay more snarky. This is the part of the AND!XOR universe that I always wish I spent more time in. When you terminal into the badge you can get a list of commands by hitting tab. (Protip: turn your caps lock on.) From there you can issue commands that may control the badge itself, the text-based story game inside of it, or the botnet being played wirelessly with other badges.
To be truly successful, you have to look around for tangential puzzles to solve, like the cipher on the back of the badge. I also noticed a peculiar flashing when the DC27 is displayed on the LEDs at startup and I’d wager there’s data hidden there. You’ll find clues in the launch video, on Twitter, and who knows where else.
The Magic is In How It’s All Pulled Together
All-in-all this a lovely piece of hardware, but the real magic is in the entire package the AND!XOR team manages to pull together for this and every previous year of their adventures. I’m amazed by their creativity in packaging along — last year they shipped in burlap bags and this year you get a sleeve in the style of the US Military “Meal, Ready-to-Eat”. Every year there is new hardware involved that I hunger to see as soon as the badge comes out — last year I ogled the GreenPAK NVM and the ISSI driver, this year it’s the light pipes and the stickers. And the alternate-reality game is beyond compare — AND!XOR did such great work with the wireless protocols that they’ve been adopted by numerous other badge makers over the years to join the botnet game, and the text-based realm within the badge is delightful and deeply engaging.
They have a huge following and are highly skilled at driving a whisper campaign that drops hints throughout the year and throughout the con. The media they put together around the project — from the stunning images and videos to the superb and thorough documentation — leave me dumbfounded. And this year they’re trying something new, offering up only about 25% of their badges to backers, which have already sold out. The cost of the other 75% of the badges has been covered by corporate sponsorship so the team will be giving away badges at DEF CON 27 and B-Sides Las Vegas for free with preference to people participating in the community nature of the events: speakers, people helping out, etc.
All of this adds up to something more than designing and selling badges. This is a movement that means something and stands for something. What that “something” is largely depends on who shows up and takes part, and I really like that.