I recently delved into the practical side of GraphQL by implementing a server using Go. This choice was driven by my recent exploration of the language, and it also serves to demonstrate that GraphQL isn't confined to JavaScript. The coding style for GraphQL libraries is quite consistent across different languages, making it accessible for developers familiar with other languages.

In this post, I walked through the process of setting up a GraphQL server. I started by defining the necessary types and schema, which included user, account, and address types. Each type is composed of basic data types like strings, integers, and floats. The query schema was then defined, including resolvers that handle the actual data fetching and processing. This setup ensures that the server can respond to GraphQL queries effectively, providing a robust and self-documenting API.

I recently explored the origins of GraphQL, a query language for APIs that Facebook developed. It's not an implementation but a specification, with many libraries supporting it. GraphQL emerged as a solution to the limitations of SOAP and REST, offering a more efficient and flexible way to fetch data.

GraphQL provides a clearly defined schema, bringing back type safety lost in the transition from SOAP to REST. It allows clients to request only the data they need, significantly reducing data fetch sizes. Additionally, documentation is defined in code, reducing the risk of mismatches. However, it's not without its challenges, such as potential request bottlenecks and the need for careful resolver management.

I recently explored the key component that sets progressive web apps apart from regular web pages: service workers. These workers act as a proxy between the network and your web page, enabling various functionalities like caching assets for offline access, serving default images, and supporting push notifications.

Service workers operate on a separate thread, which means they don't have access to the DOM or global variables. They also support only asynchronous calls and are initially downloaded after the first page load. Despite these limitations, service workers are a powerful tool for enhancing web app performance and user experience.

I recently shared my experiences from the other side of the desk, focusing on what we look for during interviews. Interviews can indeed be intimidating, but understanding the process can help alleviate some of that stress. I broke down the interview into four key sections to provide a clearer picture of what we're assessing.

Each section of the interview serves a specific purpose, from evaluating technical skills to assessing cultural fit. By understanding these components, candidates can better prepare and present their strengths. This insight not only helps in acing the interview but also in understanding what employers value in potential hires.

In the past decade, the landscape of app development has significantly evolved. Initially, web pages were the primary means of accessing content on mobile devices, but the introduction of the app store changed everything. This shift brought about the need to develop apps for both iOS and Android, leading to the rise of hybrid apps using frameworks like PhoneGap (now Cordova). However, these early hybrid apps often felt unnatural and lacked the performance and feel of native apps.

Today, technologies like React Native have bridged the gap, allowing developers to create apps that feel native while using a unified language. The future seems to be leaning towards Progressive Web Apps (PWAs), which offer the benefits of apps without the need to be on the App Store. PWAs provide offline access and a unified look and feel, making them a strong contender for rapid development and release. As a developer, I see PWAs as the next big stage, offering flexibility and performance for most applications, while native development remains crucial for those needing to maximize device capabilities.

I recently made the switch from JavaScript to TypeScript, and I must say, I'm impressed. Microsoft has done an excellent job supporting developers with this language. TypeScript offers type safety, which is a significant advantage if you've worked with languages like Java or C++. It helps catch mistakes before compilation, making your development process smoother.

Setting up TypeScript is straightforward. You need Node.js and NPM installed, and then you can add the TypeScript compiler to your project. Generating a tsconfig.json file is the next step, which allows you to customize your compilation settings. This file is crucial for configuring how your TypeScript code will be compiled into JavaScript.

I've noticed a significant shift in my coding habits recently. I haven't written a traditional for loop in months, opting instead for more modern, functional programming approaches. This isn't to say that for loops are obsolete, but their necessity has certainly diminished.

Functional programming concepts, like first-class functions, have become integral to my daily coding. For instance, in React, I often use methods like map to iterate over lists, making my code more concise and expressive.

I've been exploring AI-generated art using DALL•E 2 and Midjourney, and I'm hooked. These tools are incredibly fun and capable of producing stunning images. I don't think they'll replace artists anytime soon, but they could significantly impact stock photography.

AI-generated art is just another tool for artists, like Photoshop. It won't replace human creativity but might create new jobs for those who can master it. Each tool has its strengths—DALL•E 2 for realism and Midjourney for artistic compositions. Both have their quirks, like struggles with hands, but they're evolving rapidly.

I've been a bit quiet lately due to personal matters, but I'm excited to share that I've upgraded my drone goggles. I snagged a great deal on some second-hand Fatshark HDO goggles with an ImmersionRC RapidFire module. These goggles are top-notch, featuring OLED screens and a 37-degree field of view, making my flying experience much more immersive.

The RapidFire module is a game-changer. It combines signals from two antennas to create a clearer picture, reducing static and interference. My initial test was impressive—no more signal breakup, and an audible beep alerts me when I need to adjust my antenna direction. It's a significant upgrade from my old setup.

I recently built a new drone, inspired by Tommy's series on designing a sub 250g drone. I wanted to create something durable and lightweight, and I'm thrilled with the result. The build process was a learning experience, with key takeaways including the importance of checking arm orientation and the best way to mount camera plates.

The drone flies amazingly, offering a high thrust-to-weight ratio and confidence in tight spaces. However, it lacks a high-definition camera, so all footage is analog. I also captured a timelapse of the build process, adding a fun touch to the project. The final weight was just over 250g, but it's still incredibly agile and powerful.