Full Width [alt+shift+f] Shortcuts [alt+shift+k]
Sign Up [alt+shift+s] Log In [alt+shift+l]
39
Here’s a quick guide to setting up Remote Desktop on Windows: 1. Allow Remote Connections Right click on the My Computer icon > Click Properties > Click on the Remote tab Check the box that says “Allow Users to Connect Remotely to this Computer” Add your username to the list of allowed users, then click OK 2. Assign a static IP Address Control Panel > Network Connections > Right Click your active connection > Click Properties Select Internet Protocol Version 4 (TCP/IPv4), and then click Properties Click the “Use the following IP Address” radio button and put in valid IP info 3. Open a Port in the Router’s Firewall Browse to your router (usually 192.168.1.1 or 10.0.1.1) and log in Go to the Port Range Forward tab (Often under “Applications & Gaming”) Add an entry for Port 3389 using TCP with your static IP like this 4. Set Up Dynamic DNS Create a free No-IP account with an easy-to-remember name Download and install the No-IP DUC client and link it to your account Go to preferences in...
over a year ago

Improve your reading experience

Logged in users get linked directly to articles resulting in a better reading experience. Please login for free, it takes less than 1 minute.

More from Alex Meub

The Magic of Solving Problems with 3D Printing

3D Printing has allowed me to be creative in ways I never thought possible. It has allowed me to create products that provide real value, products that didn’t exist before I designed them. On top of that, it’s satisfied my desire to ship products, even if the end-user is just me. Another great thing is how quickly 3D printing provides value. If I see a problem, I can design and print a solution that works in just a few hours. Even if I’m the only one who benefits, that’s enough. But sharing these creations takes the experience even further. When I see others use or improve on something I’ve made, it makes the process feel so much more worthwhile. It gives me the same feeling of fulfillment when I ship software products at work. Before mass-market 3D printing, creators would need to navigate the complexity and high costs of mass-production methods (like injection molding) even to get a limited run of a niche product produced. With 3D printing, they can transfer the cost of production to others. Millions of people have access to good 3D printers now (at home, work, school, libraries, maker spaces), which means almost anyone can replicate a design. Having a universal format for sharing 3D designs dramatically lowers the effort that goes into sharing them. Creators can share their design as an STL file, which describes the surface geometry of their 3D object as thousands of little triangles. This “standard currency” of the 3D printing world is often all that is required to precisely replicate a design. This dramatically lowers the effort that goes into sharing printable designs. The widespread availability of 3D printers and the universal format for sharing 3D designs has allowed 3D-printed products to not only exist but thrive in maker communities. This is the magic of 3D printing: it empowers individuals to solve their own problems by designing solutions while enabling others to reproduce those designs at minimal cost and effort.

6 months ago 85 votes
Building the DataToaster 3000

Last summer, I was inspired by a computer that was built inside of a toaster that I saw at a local computer recycling store. The idea of a computer with the design of a home appliance was really appealing and so was the absurdity of it. It occurred to me that this would be a fun and creative way to integrate technology into my life. After thinking about it, I realized there’s also something visually appealing about how simple and utilitarian toasters are. I have major nostalgia for the famous After Dark screensaver and I think this is why. I knew now that I wanted to make my own attempt at a toaster/computer hybrid. I decided to do just that when I created the DataToaster 3000: a toaster NAS with two 3.5 inch hard disk docking stations built inside it. The hard disks can be easily swapped out (while powered off) without taking anything apart. It uses a Zimaboard x86-64 single board computer and even has a functional knob that controls the color of the power LED. I designed a fairly complex set of 3D-printed parts that attach to the base of the toaster and hold everything neatly in place. This allows it to be easily disassembled if I ever want to make any modifications and also hopefully makes the project easier to build for others. It’s a ridiculous thing but I really do love it. You can find the build guide on Instructables and the 3D models on Printables.

8 months ago 76 votes
Building a Removable Bike Basket for the Yepp Rack

I wanted to add more hauling capacity to my bike and was looking for something compatible with my Yepp rear rack. I also use my rack with a child seat (the Yepp Maxi) which has a mechanism that allows it to attach and detach easily without sacrificing safety. I was thinking it would be great to build a Yepp compatible rear basket that could I just as quickly attach/detach from my rack. I designed a removable Yepp-rack-compatible rear basket that consists of a milk crate, some plywood for stability and a 3D printed bracket threaded for M6 bolts which hold it all together. It can be attached and removed in seconds and is very secure. 3D Printed Mounting Bracket I modeled my mounting bracket after the one on the Yepp Maxi childseat. After a few iterations I was able to make it perfectly fit. I printed it in PETG filament so it was UV resistant and then installed threaded inserts for M6 bolts to attach it to the milk crate and my rear rack. 3D Print and Build Instructions You can find the 3D print on Printables and a full build guide on Instructables.

9 months ago 70 votes
The Yoto Mini is Perfect

The Yoto Mini is one of my favorite products. The team behind it deeply understands its users and put just the right set of features into a brilliantly designed package. I have no affiliation with Yoto, I’m just a happy customer with kids who love it. If you aren’t aware, Yoto is an audio platform for kids with what they call “screen-free” audio players (even though they have little pixel LED screens on them). The players are Wi-Fi enabled and support playing audio from credit card-sized NFC tags called Yoto cards. Yoto sells audio players and also licenses audio content and offers it on its platform as well. The cards themselves do not contain any audio data, just a unique ID of the audio content that is pulled from the cloud. After content is pulled on the first play, it is saved and played locally from the player after that. Yoto also supports playing podcasts and music stations without using cards. Their marketing puts a lot of emphasis on the platform being “ad-free” which is mostly true as there are never ads on Yoto cards or official Yoto podcasts. However, some of the other podcasts do advertise their content. So, what’s so great about the Yoto Mini? This concept isn’t new as there have been many examples of audio players for kids over the years. What sets it apart is how every detail of the hardware, mobile app, and exclusive content is meticulously designed and well executed. Yoto Mini Hardware The main input methods of the Yoto Mini are two orange knobs, turning the left knob controls volume and the right knob navigates chapters or tracks. Pressing the right knob instantly plays the Yoto Daily podcast and pressing it twice plays Yoto Radio (a kid-friendly music station). These actions are both configurable in the mobile app. The NFC reader slot accepts Yoto cards and instantly starts playing where you left off after you insert one. It has a high-quality speaker that can be surprisingly loud, an on/off button, a USB-C charging port, an audio output jack, and a small pixel display that shows images related to the audio content. The Yoto Mini is also surprisingly durable. My kids have dropped it many times on hard surfaces and it still basically looks as good as new. Yoto understands that the physical audio player itself is primarily used by younger kids and the design reflects this. My 3-year-old daughter was able to figure out how to turn it on/off, start listening to books using cards, and play the Yoto Daily podcast each morning which was empowering for her. This was her first technology product that she was fully capable of using without help from an adult. I can’t think of many other products that do this better. Yoto Mobile App The Yoto team understands that parents are users of this product too, mostly for managing the device and its content. Yoto has built a very good mobile experience that is tightly integrated with the hardware and provides all the features you’d want as a parent. From the app, you can start playing any of the content from cards you own on the player or your phone (nice if your kids lose a card), you can set volume limits for both night and day time, you can set alarms, and configure the shortcut buttons. You can record audio onto a blank Yoto card (which comes with the player) if your kid wants to create their own story, link it to their favorite podcast or favorite music. The app even lets you give each track custom pixel art that is displayed on the screen. Audio Content By far the most underrated feature is a daily podcast called Yoto Daily. This ad-free podcast is run by a charming British host and it is funny, entertaining, and educational. My kids (now 4 and 7) look forward to it every morning and the fact that it’s daily free content that is integrated directly into the Yoto hardware is amazing. To me, this is the killer feature, as my kids get to enjoy it every day and it’s always fresh and interesting. Yoto licenses content from child book authors, popular kid’s shows, movies, and music (recently the Beatles) which are made available in their store. I also discovered that Yoto does not seem to lock down its content with DRM. My son traded some Yoto cards with a friend and I assumed there would be some kind of transfer or de-registration process but to my surprise, they just worked without issue. Conclusion The Yoto Mini is a delightful product. The team behind it thought through every detail and made it an absolute joy to use both as a child and parent. I’m impressed at how well the Yoto team understands their users and prioritizes simplicity and ease of use above all else.

a year ago 63 votes
How To Quiet Down Your 3D Printer

When I first got my 3D printer, I built an enclosure to protect it from dust, maintain a consistent temperature, and minimize noise. I was surprised to find that the enclosure didn’t reduce noise that significantly. I then placed a patio paver under my printer, which made it noticeably quieter, but it was still audible from other rooms in my house. Recently, I found the most effective noise reduction solution: squash balls. These balls are designed with varying bounce levels, indicated by colored dots. The “double-yellow dot” balls have a very low bounce, making them ideal for dampening vibration, which is the primary cause of printer noise. I found an existing design for squash ball feet, printed it, and hot glued them evenly under my patio paver. My current setup includes the enclosure, patio paver, and squash balls under the paver. Now, the printer is so quiet that I actually can’t tell if it’s running, even when I’m in the same room. Occasionally, I will hear the stepper motors, but that’s rare. Most of the time I need to open the enclosure to make sure it’s still printing.

a year ago 33 votes

More in programming

Optimizing calling Windows DLL functions in Go

Go team wrote golang.org/x/sys/windows package to call functions in a Windows DLL. Their way is inefficient and this article describes a better way. The sys/windows way To call a function in a DLL, let’s say kernel32.dll, we must: load the dll into memory with LoadLibrary get the address of a function in the dll call the function at that address Here’s how it looks when you use sys/windows library: var ( libole32 *windows.LazyDLL coCreateInstance *windows.LazyProc ) func init() { libole32 = windows.NewLazySystemDLL("ole32.dll") coCreateInstance = libole32.NewProc("CoCreateInstance") } func CoCreateInstance(rclsid *GUID, pUnkOuter *IUnknown, dwClsContext uint32, riid *GUID, ppv *unsafe.Pointer) HRESULT { ret, _, _ := syscall.SyscallN(coCreateInstance.Addr(), 5, uintptr(unsafe.Pointer(rclsid)), uintptr(unsafe.Pointer(pUnkOuter)), uintptr(dwClsContext), uintptr(unsafe.Pointer(riid)), uintptr(unsafe.Pointer(ppv)), 0, ) return HRESULT(ret) } The problem The problem is that this is memory inefficient. For every function all we need is: name of the function to get its address in a dll. That is a string so its 8 bytes (address of the string) + 8 bytes (size of the string) + the content of the string. address of a function, which is 8 bytes on a 64-bit CPU Unfortunately in sys/windows each function requires this: type LazyProc struct { Name string mu sync.Mutex l *LazyDLL proc *Proc } type Proc struct { Dll *DLL Name string addr uintptr } // sync.Mutex type Mutex struct { _ noCopy mu isync.Mutex } // isync.Mutex type Mutex struct { state int32 sema uint32 } Let’s eyeball the size of all those structures: LazyProc : 16 + sizeof(Mutex) + 8 + 8 = 32 + sizeof(Mutex) Proc : 8 + 16 + 8 = 32 Mutex : 8 Total: 32 + 32 + 8 = 72 and that’s not counting possible memory padding for allocations. Windows has a lot of functions so this adds up. Additionally, at startup we call NewProcfor every function, even if they are not used by the program. This increases startup time. The better way What we ultimately need is uintptr for the address of the function. It’ll be lazily looked up. Let’s say we use 8 functions from ole32.dll. We can use a single array of uintptr values for storing function pointers: var oleFuncPtrs = [8]uintptr var oleFuncNames = []string{"CoCreateInstance", "CoGetClassObject", ... } const kCoCreateInstance = 0 const kCoGetClassObject = 1 // etc. const kFuncMissing = 1 func funcAddrInDLL(dll *windows.LazyDLL, funcPtrs []uintptr, funcIdx int, funcNames []string) uintptr { addr := funcPtrs[funcIdx]; if addr == kFuncMissing { // we already tried to look it up and didn't find it // this can happen becuse older version of Windows might not implement this function return 0 } if addr != 0 { return addr } // lookup the funcion by name in dll name := funcNames[funcIdx] /// ... return addr } In real life this would need multi-threading protection with e.g. a mutex. Saving on strings The following is not efficient: var oleFuncNames = []string{"CoCreateInstance", "CoGetClassObject", ... } In addition to the text of the string Go needs 16 bytes: 8 for a pointer to the string and 8 for the size of the string. We can be more efficient by storing all names as a single string: var oleFuncNames ` CoCreateInstance CoGetClassObject ` Only when we’re looking up the function by name we need to construct temporary string that is a slice of oleFuncNames. We need to know the offset and size inside oleFuncNames which we can cleverly encode as a single number: // Auto-generated shell procedure identifier: cache index | str start | str past-end. const ( _PROC_SHCreateItemFromIDList _PROC_SHELL = 0 | (9 << 16) | (31 << 32) _PROC_SHCreateItemFromParsingName _PROC_SHELL = 1 | (32 << 16) | (59 << 32) // ... ) We pack the info into a single number: bits 0-15 : index of function in array of function pointers bits 16-31: start of function name in multi-name string bits 32-47: end of function name in multi-name string This technique requires code generation. It would be too difficult to write those numbers manually. References This technique is used in https://github.com/rodrigocfd/windigo win32 bindings Go library. See e.g. https://github.com/rodrigocfd/windigo/blob/master/internal/dll/dll_gdi.go

yesterday 2 votes
Lessons along the EndBOX journey

How a wild side-quest became the source of many of the articles you’ve read—and have come to expect—in this publication

2 days ago 3 votes
Making System Calls in x86-64 Assembly

Watch now | Privilege levels, syscall conventions, and how assembly code talks to the Linux kernel

3 days ago 5 votes
Better Test Setup with Disposable Objects (article)

Learn how disposable objects solve test cleanup problems in flat testing. Use TypeScript's using keyword to ensure reliable resource disposal in tests.

3 days ago 6 votes
Digital Ghosts, Wisdom, and Tennis Matchmaking

Digital Ghosts My mom recently had a free consultation from her electric company to assess replacing her propane water heater with an electric water pump heater.  She forwarded the assessment report to me, and I spent some time reviewing and researching the program. Despite living quite far away, I have been surprised by how much […]

3 days ago 6 votes