DEV Community: Chris Watson

25 Web Design Trends to Watch in 2025

Chris Watson — Tue, 15 Apr 2025 19:46:36 +0000

Every year, I like to take stock of where web design is headed—and 2025 is shaping up to be one of the boldest years yet. This roundup covers 25 of the biggest web design trends I'm seeing across the internet right now. Whether you're a fellow dev, a designer, or a founder figuring out what the hell to do with your homepage, this should help spark some ideas.

This originally appeared on Spectrum IT Consulting, where I share more resources and insights for growing businesses through thoughtful design and tech.

🚀 Interactive and Immersive Experiences

1. Micro Animations

Tiny details with big impact. Micro animations help guide users, reinforce actions, and give interfaces that extra bit of polish. Think hover effects, button ripples, loading indicators—they're subtle, but powerful.

2. Cursor Animation

Custom cursors are in. Designers are using them as brand elements—everything from sparkly trails to responsive morphing shapes. It’s weirdly delightful.

3. Scroll-Triggered Animations

Forget static content. Scroll-triggered animations add drama and structure to the experience—elements zoom, slide, or fade in as you scroll. It's like turning a page in a story.

4. Experimental Navigation

Hamburgers and dropdowns? Snooze. 2025 is full of weird nav: radial menus, scrolling-as-navigation, and even gesture-based navigation on some sites. It’s not for every project, but damn does it stand out.

5. Non-Traditional Scrolling

Sideways, diagonal, sticky-scroll, or scroll-jacking in a good way—creativity is bleeding into scroll mechanics, making them part of the storytelling experience.

🎨 Visual Design Elements

6. Futuristic, Sci-Fi Gaming UI Aesthetics

Interfaces inspired by games and sci-fi films are on the rise—think neon glows, HUD-style overlays, and glitchy transitions.

7. Brutalist Design

Unapologetically harsh layouts, massive fonts, and clashing elements. Brutalism is still kicking, especially in indie and portfolio sites. Bonus points if you blend it with modern techniques like I did on my own site.

8. Organic Matter

Designs with earthy textures, wavy lines, and organic flow are balancing out the cold, minimal vibes of the past few years.

9. UFOs (Unexpected Floating Objects)

Floating shapes, drifting blobs, and gravity-defying elements that dance on the screen. They break the grid in fun ways and keep things playful.

10. Full-Screen Headers

The “above the fold” area is now “above everything.” Full-screen headers are visually intense and set the tone right away.

11. 3D Websites

WebGL and friends are being used for more than just cool portfolios—product showcases, interactive charts, and landing pages are all getting the 3D treatment.

🧱 Layout and Structure

12. Bento Grid / Bento UI

Inspired by Japanese bento boxes, this layout style uses modular blocks to organize content. Great for portfolios and dashboards.

13. Grid Design (With a Twist)

Asymmetric grids are hot. Breaking the perfect grid rules adds personality while keeping layouts structured.

14. Negative Space / White Space

Whitespace isn't just trendy—it’s foundational. It makes everything breathe and helps direct attention to the stuff that matters.

🔠 Typography and Color

15. Expressive Typography

Type is no longer just functional. It's huge, it's moving, it's animated. Designers are using expressive fonts as centerpieces instead of just accents.

16. Color Trends

We’re seeing bold contrasts, saturated gradients, transparent overlays, and interactive themes that respond to user preferences. It's like a paint party for the web.

17. Dark Mode and Light Mode

It’s not just about flipping between black and white anymore. Great dark mode means rethinking design balance, color theory, and accessibility from the ground up.

🧾 Content Presentation

18. Text-Only Websites

Text-only layouts are coming back—especially for writers, devs, and minimalist blogs. Super fast, super readable, super raw.

19. Custom Illustrations

Illustrations give a site instant personality. Bonus points if they're animated or interactive.

20. Blending Images and Graphics

Mixing photography with graphical overlays—like doodles, arrows, and collage elements—is a killer way to add context and creativity.

⚙️ Technical Enhancements

21. Chatbot Design

Bots have grown up. They’re now brand reps with personality, custom UIs, and seamless interactions. Think less "tech support" and more "concierge."

22. Smart Videos

Silent by default, looped seamlessly, and designed for performance—videos are now ambient design elements instead of content hogs.

23. Anti-Design

This is the punk rock of web design—clashing colors, chaotic layouts, ugly fonts, and attitude. It shouldn’t work, but sometimes it really does.

24. Increased Focus on UX/UI

The best UI is the one you don’t notice. Expect even more obsession with micro-interactions, user flow, and intuitive design.

25. Responsive Web Design

This isn’t a trend—it’s a necessity. But the approach is getting smarter. Think foldables, ultrawides, and screen ratios that weren’t even on our radar 5 years ago.

Final Thoughts

2025 web design is all about personality, playfulness, and performance. Trends are moving fast, and if you're not keeping up—you’re falling behind.

If you’re working on a redesign or planning something new, feel free to reach out. I help businesses build modern, performant websites that are anything but boring. You can check out more of my work and get in touch at Spectrum IT Consulting.

Meet PostPilot

Chris Watson — Mon, 11 Nov 2024 23:14:32 +0000

Anyone that's been in web development long enough is familiar with the struggles of testing email, since so many applications require the ability to send emails for one reason or another. Whether it be for authentication, notifications, or just about anything else, email is a crucial part of of the web as it has been for the past few decades.

The problem is that testing email sending is a pain, and for most developers it means setting up SendGrid, Mailgun, or enabling SMTP on their personal email account. Moreover, once you start actually sending emails you have to deal with them clogging up your inbox while you're testing.

Granted there are a ton of ways around this. Just to name a few:

Use your personal email account (Gmail, Fastmail, ProtonMail, etc.) and enable SMTP
Have a local mail server be part of your development environment, along with a frontend like SquirrelMail or RainLoop
Go the tried and true route of setting up an email service like SendGrid, Mailgun, or Postmark

While these are all valid solutions which I've tried (other than setting up a local mail server), they all have their own drawbacks.

For example, using your personal email account is great for a quick and dirty solution, but it doesn't scale well when you're testing a large number of emails. Setting up a local mail server is a bit more involved, and while it does scale it adds another layer of complexity to your development environment. Using an email service is a good middle ground, but it adds another dependency to your project and can incur additional costs.

Enter PostPilot

For these reasons and more, I've been working on PostPilot, a free and open source email testing tool inspired by Mailpit and Laravel Herd.

For those that aren't aware, the Herd developers solved this issue as a part of the Laravel stack a while ago by creating a nice GUI that lists sent emails and allows you to view and interact with them. It's a beautiful solution and makes the $100 for a Herd Pro license almost worth it (the other parts of Herd take it from an almost to a definite yes). Unfortunately, it's not free, not open source, only available on macOS and Windows, and is mostly useful for the Laravel ecosystem.

Like Mailpit, PostPilot is written in Go and comes complete with a beatiful UI, notifications, and the ability to interact with incoming emails. Unlike Mailpit, PostPilot is a GUI application rather than a headless server with a web interface. I won't say either is better or worse, but they do cater to a different audience as far as preferences go.

What's next?

PostPilot is in very active development and is very much still in the early stages. I just released version 0.1.2 which is the first actual release, and I have managed so far to get a build process in place for Linux and Windows. As of right now, the recommended way to run PostPilot on macOS would be to build it from source. Once I get to the point where I can afford an Apple developer account and a Windows signing certificate, I'll start working on installers for both platforms.

The next things I'll be working on are better documentation for the development process, and then I'll be attempting to get some of the more popular features from Mailpit working, like SpamAssassin integration and the ability to filter emails based on certain criteria.

If you're interested in following along or contributing, you can find the project on GitHub, and if you want to help me with the ability to get Windows and macOS builds out you can always support me on Patreon, Github Sponsors, or Ko-Fi.

Rediscovering PHP: A Modern Alternative to JavaScript Fatigue

Chris Watson — Thu, 17 Oct 2024 19:28:59 +0000

For many developers, PHP conjures memories of tangled codebases, inconsistent syntax, and a language that seemed stuck in the past. If you've spent the last decade distancing yourself from PHP, you're not alone. But as the JavaScript ecosystem becomes increasingly complex, it's worth reconsidering PHP as a viable and even superior alternative for certain projects. This post aims to shed light on how PHP has evolved and why it might just be the refreshing change you're looking for.

The JavaScript Landscape: A Double-Edged Sword

JavaScript has undeniably revolutionized web development, enabling rich, interactive experiences on the client side. However, the ecosystem has become a labyrinth of frameworks, libraries, and build tools. The constant churn—new frameworks supplanting old ones, frequent breaking changes, and an overwhelming number of choices—can lead to what's often termed "JavaScript fatigue".

Common Pain Points:

Overwhelming Choices: React, Angular, Vue, Svelte—the list goes on.
Complex Tooling: Webpack, Babel, ESLint, and a myriad of plugins.
Rapid Obsolescence: Libraries and frameworks can become outdated quickly.
Inconsistent Practices: Diverse paradigms and styles leading to fragmented codebases.

PHP's Renaissance: Not the Language You Remember

Contrary to its reputation from a decade ago, PHP has undergone significant transformations. Modern PHP is a robust, performant, and developer-friendly language that addresses many of the issues that led developers to abandon it in the first place.

Key Improvements in PHP:

Modern Syntax and Features: Introduction of type declarations, anonymous classes, arrow functions, and more.
Performance Enhancements: PHP 7 and 8 have brought massive speed improvements and reduced memory usage.
Better Error Handling: Engine exceptions and clearer error messages make debugging easier.
Strong Community and Ecosystem: Frameworks like Laravel and Symfony embrace modern development practices.

Breaking Down PHP's Evolution

1. Type Safety and Modern Language Features

Then (2010):

Weak typing led to unexpected behaviors.
Lack of modern programming constructs.

Now:

Scalar Type Declarations: Enforce types for function parameters and return values.
Union and Intersection Types: Allow variables to hold multiple types.
Nullable Types: Explicitly define if a variable can be null.
Arrow Functions: Concise one-line anonymous functions.

Benefit: Reduced runtime errors and more predictable code.

2. Performance That Rivals Competitors

Then (2010):

Considered slow and resource-intensive.
Not suitable for performance-critical applications.

Now:

PHP 7 and 8: Up to 3x performance improvements over PHP 5.
Just-In-Time Compilation: Introduced in PHP 8.0 for even faster execution.
OPcache Extension: Built-in caching mechanism for bytecode.

Benefit: Faster response times and the ability to handle more traffic with fewer resources.

3. Asynchronous Programming and Real-Time Applications

Then (2010):

Limited to synchronous execution.
Not suitable for real-time applications like chat or gaming servers.

Now:

Async Libraries: Tools like ReactPHP and Amp bring asynchronous programming to PHP.
WebSockets Support: Enable real-time, bidirectional communication.

Benefit: Build scalable real-time applications without switching languages.

4. Robust Frameworks and Tooling

Then (2010):

Few frameworks, often with inconsistent practices.
Lacked modern development tools.

Now:

Frameworks: Laravel, Symfony, and Slim provide solid foundations.
Composer: Dependency management akin to npm, streamlining package installation.
Testing Tools: PHPUnit, Pest, and Mockery for comprehensive testing.
Static Analysis: Tools like PHPStan and Psalm improve code quality.

Benefit: Accelerated development with reliable, well-maintained tools.

5. Improved Syntax and Developer Experience

Then (2010):

Verbose and sometimes inconsistent syntax.
Lacked features to write clean, maintainable code.

Now:

Cleaner Syntax: Features like the null coalescing operator (??), spaceship operator (<=>), and match expressions.
Attributes and Enums: Introduced in PHP 8 for better code organization.
Enhanced Error Handling: Using try-catch blocks with multiple exceptions.

Benefit: Write cleaner, more maintainable code that is easier to read and debug.

PHP vs. JavaScript: Where PHP Shines

1. Simplicity Over Complexity

PHP offers a more straightforward approach to web development. With a single, cohesive language for both front-end (with templating engines) and back-end, the cognitive load is reduced.

Example: Building a simple CRUD application can be faster and less complex in PHP using frameworks like Laravel, compared to setting up a full JavaScript stack.

2. Stability and Backward Compatibility

PHP maintains a focus on backward compatibility and gradual deprecation, minimizing the impact on existing codebases.

Contrast: JavaScript frameworks often introduce breaking changes that require significant refactoring.

3. Mature Ecosystem for Web Development

PHP was built for the web. It excels in serving dynamic web pages and has a mature ecosystem for tasks like:

Content Management Systems: WordPress, Drupal, and Joomla.
E-commerce Platforms: Magento, PrestaShop.
API Development: Quick and efficient RESTful APIs.

Common Use Cases Where Modern PHP Excels

Command-Line Applications and Automation

Symfony Console: Build powerful CLI tools.
Automation Scripts: Manage tasks like deployments and database migrations.

Static Site Generation

Tools: Sculpin and Jigsaw allow you to generate static sites with PHP.
Benefits: Utilize PHP's templating engines for static content.

Microservices and APIs

Lightweight Frameworks: Slim and Lumen for microservices.
Performance: Efficient handling of API requests with low overhead.

Real-Time Applications

WebSockets: Implement real-time features like chats and notifications.
Async PHP: Handle concurrent connections efficiently.

Embracing PHP in a Modern Workflow

Composer: PHP's Package Manager

Dependency Management: Easily include and manage libraries.
Packagist Repository: Access to thousands of packages.

Frameworks That Leverage Modern PHP

Laravel: Offers elegance and simplicity.
Symfony: A robust enterprise-level framework.
API Platform: Build APIs effortlessly.

Interoperability and Integration

Docker Support: Containerize PHP applications for consistency across environments.
Continuous Integration: Integrate with tools like Jenkins, Travis CI, and GitHub Actions.

Overcoming the Stigma: Why You Should Give PHP Another Chance

Misconceptions Persist

Many criticisms of PHP are based on outdated information or experiences from older versions.

Community and Support

A vibrant community contributes to an ever-improving ecosystem, providing tutorials, packages, and support.

Job Opportunities

PHP remains widely used in the industry, with many companies seeking developers proficient in modern PHP.

Getting Started with Modern PHP

Update Your Knowledge

Documentation: Visit the official PHP docs to learn about new features.
Tutorials: Platforms like Laracasts offer in-depth lessons.

Experiment with Frameworks

Laravel New: Create a new Laravel project and explore its features.
Symfony Demo: Test out Symfony's capabilities with their demo application.

Join the Community

Conferences: Attend PHP conferences and meetups.
Forums and Groups: Engage with others on platforms like Reddit's r/PHP or PHP UG groups.

Conclusion: A Fresh Start with PHP

If you've been disheartened by the complexities of the current JavaScript ecosystem, it's time to take a fresh look at PHP. The language has matured significantly, shedding its old baggage and adopting modern programming paradigms. With improved performance, a wealth of new features, and a focus on developer experience, PHP offers a stable and efficient alternative for web development and beyond.

So, dust off your old perceptions, and give PHP another chance. You might be pleasantly surprised by what you find.

Thank you for reading! If you have experiences with modern PHP or thoughts on the current state of JavaScript, feel free to share in the comments below.

Cursor has a problem, and it's not just the price

Chris Watson — Wed, 16 Oct 2024 16:49:55 +0000

Cursor is a controversial AI code editor forked from VS Code and backed by Y Combinator. The controversies range from the $20-a-month price tag for a limited number of queries, to the closed-source nature of the editor, which was forked from an open-source project, and, of course, to the broader controversy around AI itself. However, this post isn't about any of that.

Surprisingly, one issue I haven't seen discussed much is how Cursor seems to treat Linux as a second-class citizen. To understand what I mean by that, it's important to understand the AppImage format. So let's dive into that for a moment.

The AppImage

In simple terms, AppImages are a "build once, run anywhere" package format for Linux. They bundle all the necessary files, including shared libraries, into a virtual filesystem and add a runtime layer that makes launching your app straightforward. If this sounds similar to Flatpak and Snap, that's because it is. The key difference is that you don't need to install anything to run an AppImage—everything is self-contained.

AppImages, however, come with their own set of issues. One major drawback is that they can't be easily installed like applications from your distribution's package manager. While you can download and run them without much hassle, they lack desktop integration unless you put in extra effort. Tools like AppImagePool and Gear Lever help alleviate this, but at that point, you might as well use Flatpak or Snap to benefit from their built-in sandboxing capabilities.

Cursor on Linux

When you download Cursor for Linux, you get an AppImage. If you're using a distribution like Arch, this isn't as much of an issue because the AUR provides a way for users to make the installation process easier (though it's not perfect, as we'll discuss). For the majority of other distributions, however, you're stuck dealing with the AppImage format and its limitations. Now we can finally get to the part that's been the biggest pain for me.

Coming from VS Code, I had certain expectations when using Cursor. Call it a first-world problem, but I want to be able to launch the editor from the command line, just like you can with VS Code's shell command. You can get part of the way there by renaming cursor.AppImage to cursor and adding it to your PATH, but this approach is flawed. The biggest issue—at least from my perspective—is that it takes over the terminal, making the window/tab unusable while Cursor is open. It also means you have to keep the terminal open.

To address this, you can run the process in the background using cursor . &, but this still results in occasional logs appearing in your terminal. To suppress these, you can pipe the output to /dev/null by running cursor >/dev/null 2>&1 &. While this mostly resolves the problem, it's not a very convenient command to run every time you open Cursor.

Ultimately, installing Cursor on Linux is cumbersome, and using it remains a hassle compared to alternatives like VS Code or Zed.

The Solution

One potential solution is to add a cursor function to your shell profile to handle launching Cursor. This is the workaround I've been using, but it's still far from ideal. Not only do I have to write the script myself, but I also need to set it up on every system where I want to use Cursor. Moreover, I still have to deal with manually installing the AppImage, and updating it requires re-downloading from the Cursor website.

So I did what I do best—I wrote some code. Specifically, I created a few bash scripts and made them available for anyone to use. You can find the project at github.com/watzon/cursor-linux-installer, and it can be installed with a single CURL command:

curl -fsSL https://raw.githubusercontent.com/watzon/cursor-linux-installer/main/install.sh | bash

Since all of the code is public, I encourage you to audit it before running it, and please let me know if you encounter any issues. I'm fully aware that this is a solution looking for a problem, but it has been a personal annoyance for me, and until the Cursor team decides to create distro-specific installers or a Flatpak version, this is the method I'll continue using.

Thanks for reading!

Safari-like archive handling in Linux

Chris Watson — Sun, 19 Sep 2021 01:12:05 +0000

Just wanted to share this, because I spent all morning figuring it out for myself. As someone that's used macOS a lot recently one of the features I really appreciate is Safari's ability to automatically extract archives when you open them. Granted that's about the only feature I appreciate about Safari, but I'll give credit where credit is due.

Having recently reinstalled Arch on my home workstation this is one the the features that I've really missed, so this morning I decided to add the feature myself.

Starting off I knew I'd most likely need to write a script and somehow associate the mime-types of the various archives I want to open with that script. Keep in mind that these instructions are known to work on GNOME and require the zsh shell. Different types of archives also require different programs to open them.

Here are the 2 files you're going to need. I'll explain them a bit further down.

First is extract.zsh (place this in ~/.local/bin):

And then the desktop file (place this in ~/.local/share/applications:

How does it work?

Honestly it's super simple, and makes use of some existing code from Oh-My-ZSH. extract.zsh checks the extension of the file you're trying to extract and matches it with the correct program for opening that file. This script was meant to be used as a zsh plugin, but I repurposed it. In doing so I needed to change the output directory (initially files were being extracted to my user's home directory) and make it automatically overwrite existing directories since we wanted this process to be automatic.

The .desktop file allows the script to be registered as the default program for a given mime-type. All you have to do is open one archive with a given extension using the extract menu option and that's it, extract is now the default program for opening those archives.

Now for the little bit of setup:

Any archive formats you want to have automatically extract need to be opened with extract so that the default for that archive type can be changed. To do this (on GNOME) right click an archive, select "Open With Other Application", click "Find New Applications" at the bottom of the dialog, and then find extract in the list. If you don't see it you may need to log out and then log back in again.

That's really it. Now download an archive and try opening it directly from the downloads menu in your browser. The archive should be extracted and then the directory automatically opened.

Debugging Zig with VS Code

Chris Watson — Tue, 07 Jul 2020 22:07:03 +0000

I've seen questions regarding this both on Reddit and in the Zig Discord, so I wanted to take a minute to share to all those Ziggites (Ziggies? Ziggos? Zigstronauts?) out there how to easily debug their Zig programs using VS Code and GDB.

First, of course, you will need both VS Code and GDB installed. If you don't... well get them. I'll wait.

Now, with VS Code opened, press Ctrl + p (Cmd + p for those Mac people), paste ext install webfreak.debug into the command input box, and hit enter. This will install the wonderfully built Native Debug extension for VS Code which supports GDB and LLDB. In this walkthrough I'll be giving GDB instructions, but you should be able to make it work with LLDB with very few changes.

Now we need to make a build file. Since Zig is compiled, your program obviously needs to be built before it can be run. Press Ctrl + Shift + p and search for "Tasks: Configure Default Build Task", select it, and follow the prompts until you have a tasks.json file created. You will want to create a "build" task which basically runs zig build with whatever arguments you need. As a point of reference, mine looks like this:

{
    "version": "2.0.0",
    "tasks": [
        {
            "label": "build",
            "type": "shell",
            "command": "zig build",
            "problemMatcher": [],
            "group": {
                "kind": "build",
                "isDefault": true
            }
        }
    ]
}

all it does is run zig build in the current working directory. My build.zig file does the rest.

Next you will need a launch.json. This can be created by once again pressing Ctrl + Shift + p and searching for "Debug: Open launch.json". When prompted, choose the "C++ (GDB/LLDB)" option. This will generate a launch.json file for you, which will be responsible for telling VS Code how to launch and attach the debugger, in our case GDB.

You'll need to change the program option to the location where your built program will be output, in my case it's "./zig-cache/bin/build", but this will vary.

You'll also need to add preLaunchTask as an option, and set its value to the name of your build command. In the above example the task name is "build". Your final launch.json should look something like this:

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "(gdb) Launch",
            "type": "cppdbg",
            "request": "launch",
            "program": "./zig-cache/bin/build",
            "args": [],
            "stopAtEntry": false,
            "cwd": "${workspaceFolder}",
            "environment": [],
            "externalConsole": false,
            "MIMode": "gdb",
            "preLaunchTask": "build",
            "setupCommands": [
                {
                    "description": "Enable pretty-printing for gdb",
                    "text": "-enable-pretty-printing",
                    "ignoreFailures": true
                }
            ]
        }
    ]
}

And that's really it. Try it out by setting some breakpoints in your code, heading over to the debug tab in the activity bar, and pressing play.

Hope this helped!

Browsing The Web With Crystal

Chris Watson — Mon, 12 Aug 2019 06:39:33 +0000

If you've been in the web development industry for any decent amount of time it's likely you've heard mention of tools like Selenium, WebDriver, and Puppeteer. These are mainly touted as "testing automation frameworks" because they enable developers to automate the testing of web apps by saying "go here", "click this", "take a screenshot and compare it against a previous screenshot and make sure nothing's changed". These tools are also helpful with web scraping, as they allow you to see web pages exactly as the browser sees them. This means JavaScript rendered content is scrapable!

To date Selenium is probably the most popular of these tools. It's used everywhere, from testing environments and CI's to web scrapers and pentesting tools. It is extremely powerful, but has one major drawback. Java.

Anyone who's used written or used a Java application knows that it has one major drawback. Memory usage. Java applications are heavy, which limits their usefulness on systems with less resources and containerized applications. This doesn't stop people from trying, but why use extra resources if you don't have to?

So, with speed and memory efficiency in mind, I set about recently to devise my own solution for the Crystal ecosystem; a solution I decided to call Marionette after the Firefox Marionette protocol.

Exploring Marionette

Of course before wrapping any kind of API you have to do some research. Unfortunately, Marionette is not super well documented. Marionette and WebDriver share a lot in terms of methods and functionality, with Marionette building on top of the functionality that the WebDriver protocol provides.

Naturally my first Google search was for "firefox marionette protocol", which led me to this page which describes the protocol, but not in near as much detail as I'd hope. That being said, it does at least describe the format that a message must take when being sent to Firefox. Unfortunately after browsing the whole Marionette section of that site I didn't find any information on what commands the Marionette protocol accepted. So I continued my search.

Something I had seen in the Marionette documentation was mention of a Python client. Now I make it very well known to people I talk to my extreme distaste for all things Python, but if it could help me figure out what methods the Marionette protocol had available it would be worth it. So I followed a link to their reference client and dove into the Python code (which I was happy to find was actually very well written).

After a little bit of digging I found what I was looking for! This file includes most of the methods that the Python client uses for interacting with Marionette,including the names of the methods and the format in which messages are sent. And so began the process of building my own client.

Building the Client

The main client functionality was fairly straightforward, seeing as I had a fully functioning Python client to work off of. I also managed to find a client written in Go that was very similar, but not quite as powerful as the Python client. I still have never managed to find a list of RPC commands that Marionette accepts, but between those two clients I was able to build my own fairly easily.

Now this project wouldn't have been possible, at least not in the amount of time I've been able to get it working, without the help of NeuraLegion, my employer who is sponsoring its development.

NeuraLegion is an application security company with a SASS AIAST solution powered by AI. Or, for people who don't speak penetration tester, a company that tests the security of websites and other applications using software that's powered by artificial intelligence. That software has to be capable of browsing the web in the same way as you or I, but it also needs to be able to do things you normally don't do in every day web browsing, such as modify HTTP headers, send attack payloads in a POST request to an open API route, etc. Because of this, just a standard Selenium type client wasn't good enough.

We needed a proxy.

Building the Proxy

There are two main types of proxy: a forward proxy which is used to forward outgoing requests from a private network or intranet to the Internet, usually through a firewall, and a reverse proxy which retrieves resources on behalf of a client from one or more servers; these resources are then returned to the client, appearing as if they originated from the proxy server itself.

Firefox, and thereby marionette, has built in support for forward proxies. All you have to do is provide it with a address for the HTTP proxy, HTTPS proxy, and potentially FTP and SOCKS proxies and it will tunnel all requests through those before hitting the browser. Unfortunately this requires a separate proxy for each, and tunneling HTTPS requests turns out to be much more difficult. So it was decided that a reverse proxy would make more sense.

I won't go into full detail about how the reverse proxy works, if you want to check out the code you can find it here. Basically what it all amounts to is this:

When Marionette is launched with the extended option set to true a Proxy object is instantiated and the server is launched. The Browser#goto method then forwards all navigation requests to the proxy and tells it what page to fetch. The proxy fetches the resource and does a little gsub magic on the page's content, replacing all internal links with a link to the proxy server instead. All internal resources are then tunneled though the proxy as they're fetched, allowing us to potentially be able to modify javascript, images, etc. before they reach the page. Everything is then packaged back up and returned to the browser as if nothing had happened.

Basically what this means is that you can do whatever you want with pages before the browser even knows they've been touched, which can be very powerful for AppSec.

Using It

Ok so I've done enough boring you with how Marionette works under the hood, let's look at how you actually use it.

First, in case it wasn't obvious or if you just jumped down to this section, Marionette requires Crystal to run. So if you don't have Crystal installed you may want to go download it if you intend to follow along. You will also need Firefox installed.

The first thing you'll need to do is fire up your terminal and create a new Crystal project.

crystal init app browser
cd browser

Then add Marionette as a dependency in your shard.yml file.

dependencies:
  marionette:
    github: watzon/marionette
    version: 0.1.0

Now run shards install in your terminal and Marionette should be installed to the lib directory.

Now let's open up src/browser.cr and add the following content:

require "marionette"

Marionette.launch do
  goto("https://dev.to")
  puts title
  puts url
end

Make sure Firefox is not currently running, if it is this won't work since Firefox only allows one instance at a time. Now in your terminal run

crystal run ./src/browser.cr

After a few seconds you should see a bunch of debug statements in blue and in white

DEV Community 👩‍💻👨‍💻
https://dev.to/

Congrats! It worked! But that's not even close to all Marionette has to offer. Why don't we do something fun, like take a screenshot.

require "marionette"

Marionette.launch do
  goto("https://dev.to")
  save_screenshot("dev.to.jpg", full: false)
end

As of the time of writing, this is what "dev.to.jpg" looks like:

The full: false option allowed us to just capture what's in the viewport. If you didn't have that option set to true you would end up with a very large image.

For our last little test, let's visit a bunch of sites and then export a HAR file. A HAR file, for those that aren't aware, is a JSON-formatted archive file format for logging of a web browser's interaction with a site. Basically it is able to store all the details about a page load.

require "marionette"

Marionette.launch do
  goto("https://www.google.com")
  goto("https://neuralegion.com")
  goto("https://watzon.tech")
  export_har("multisite.har")
end

After this finishes running you should have a file called multisite.har in your current working directory. You can test that it worked correctly by using Google's HAR Analyzer.

I have tried to document Marionette extremely well in the readme and in the official documentation, so if you're interested in the project please go take a look. Contributions are always accepted, as are suggestions.

Thanks for reading this. Please don’t forget to hit one of the the Ego Booster buttons (personally I like the unicorn), and if you feel so inclined share this to social media. If you share to twitter be sure to tag me at @_watzon.

Some helpful links:
https://crystal-lang.org/
https://github.com/kostya/benchmarks
https://github.com/kostya/crystal-benchmarks-game
https://github.com/crystal-lang/crystal

Find me online:
https://medium.com/@watzon
https://twitter.com/_watzon
https://github.com/watzon
https://watzon.tech

Understating abstract classes

Chris Watson — Sat, 27 Jul 2019 05:54:49 +0000

Before we begin, mandatory dictionary definition:

ab·stract [adj] /abˈstrakt,ˈabˌstrakt/

existing in thought or as an idea but not having a physical or concrete existence.

Abstractions are an extremely helpful, albeit difficult to understand concept in programming. After all, if abstractions were easy to understand they probably wouldn't be abstract... Would they?

Abstract classes are just one form of abstraction that exists in programming, and the one I'll be going over in this post. This was inspired by a question from @girng on the crystal-lang forum. Since the original question was a Crystal question, and since Crystal is currently my favorite language I will be using Crystal examples, but a lot of the concepts transfer to other languages, even if the implementation is different.

What are abstract classes?

Abstract classes are classes which are meant to be inherited, but not instantiated. They act as a base for other classes by providing methods that are should exist on all child classes without actually implementing those methods.

An example of a simple abstract class is as follows:

abstract class Foo
  abstract def bar(text : String) : Array(String)
end

In this case we have a class Foo which has an abstract method bar. The bar method must accept a single string parameter and must return a string array. Note that if we try and create an instance of the Foo class the compiler will throw an error. If we want Foo to be useful we have to extend it.

class Baz < Foo
  def bar(text : String)
    text.split(" ")
  end
end

Now we've defined a class Baz which implements the bar method exactly as described. Let's try and make the compiler throw an error though.

# This will throw an error since `bar` is not defined on `Baz`
class Baz < Foo
end

# This will throw an error since `bar` has the incorrect definition
class Baz < Foo
  def bar(opts : Array(String))
    opts.join
  end
end

Abstract classes can also define actual methods to be included in child classes. Those methods can be initializers or any other type of method.

class Foo
  def initialize
    puts "#{self.class} initalized"
  end

  abstract def bar(text : String) : Array(String)
end

class Baz < Foo
  def bar(text : String)
    text.split(" ")
  end
end

baz = Baz.new
# => "Baz initalized"

Where should I use them?

Abstract classes are useful in a number of situations, but the number one example that springs to mind is with adapters, such as for different databases. Databases are a good example because they all have similar functionality, but they all do things in a slightly different way.

Here is a super basic example:

class Connection
  # Implementation
end

abstract class Adapter

  def initialize(@name : String, @url : String)
  end

  abstract def insert(table, fields) : Int64

  # Other methods...

end

class Mysql < Adapter
  def insert(table, fields)
    # Insert stuff
    0
  end
end

class Postgres < Adapter
  def insert(table, fields)
    # Insert stuff
    0
  end
end

Obviously this is not a functional example, but it should compile and illustrates the basic concept. For a working example you can check out Granite::Adapter::Base from amberframework/granite.

Some helpful links:
https://crystal-lang.org/
https://github.com/kostya/benchmarks
https://github.com/kostya/crystal-benchmarks-game
https://github.com/crystal-lang/crystal

Find me online:
https://medium.com/@watzon
https://twitter.com/_watzon
https://github.com/watzon
https://watzon.tech

Doing Crystal #3: Types, types, types

Chris Watson — Thu, 23 May 2019 11:26:58 +0000

Welcome to the third post in my Doing Crystal series. In this post I'll be focusing on Crystal's type system, it's benefits, and the drawbacks. If you haven't read the other articles in this series you can find them here, and here for posts one and two respectively.

Static vs Dynamic Typing

Static typing has existed in programming for years, going back as far as FORTRAN which was first released back in 1957. Now in truth all programming languages are typed, even languages such as JavaScript and Ruby have types such as Integers, Arrays, and Strings. This is necessary because in the real world things have specific properties which are unique to that thing. Numbers and strings are inherently different and, even though you could technically add a number to a string by taking the string down to its binary representation and adding the number to that, in real world terms it just doesn't make sense. Hence, we have types.

The difference is in how the types are handled. With languages like JavaScript and Ruby types are handled dynamically. This allows you to do things like the following Ruby example:

def first_and_last(arr)
  if arr.length > 0
    return [arr.first, arr.last]
  end

  []
end

puts first_and_last(["Hello", "fellow", "developers"])
# => ["Hello", "developers"]

puts first_and_last(42)
# => NoMethodError (undefined method `length' for 42:Integer)

As you can see, the method first_and_last is supposed to accept an Array and return the first and last elements as a new Array. It works fine when handed the type of data it expects, but when handed a number it throws a runtime error NoMethodError. Dynamic typing can be extremely handy, but it can also be detrimental as a large number of runtime errors (or errors that occur while your program is running as opposed to when it's compiled) occur when the program attempts to use a method that doesn't exist, or when a variable's type changes unexpectedly.

Now let's look at the same code from before, but in Crystal.

def first_and_last(arr : Array(U)) forall U
  if arr.size > 0
    return [arr.first, arr.last]
  end

  [] of U
end

puts first_and_last(["Hello", "fellow", "developers"])

puts first_and_last(42)

For this one I didn't show an output. Why? Because the program won't compile. Let's go over the program line by line, and then I'll explain why the compilation fails.

def first_and_last(arr : Array(U)) forall U

First we do a method definition. This is similar to the Ruby example, but there a a couple of important differences. First we have the weird arr : Array(U) syntax. This is setting the property name to arr and the type of arr to an Array of type U. U in this case is a placeholder type, and outside the scope of this tutorial, but suffice it to say it allows U to be anything. The forall U part at the end creates the U generic.

if arr.size > 0
  return [arr.first, arr.last]
end

This is exactly the same as the Ruby example save the slight method name change for getting the size of an array. In Ruby it's length and in Crystal it's size.

[] of U

In Crystal all things have a specific type. This prevents runtime errors and lowers memory usage since the program can allocate the resources it knows it needs. As such, all Arrays, Hashes, Sets, etc. have to be explicitly typed and that is what this line is doing. If the Array the method is handed doesn't have anything in it we just return an empty Array. Truthfully we probably should've returned the same array we were given, but I wanted to show an example of assigning an Array a type.

puts first_and_last(["Hello", "fellow", "developers"])

This line will work as expected and return ["Hello", "developers"].

puts first_and_last(42)

This is the line that breaks things. Our method expects an Array, but instead we handed it an Int32. Because of this breach of contract the compiler throws an exception.

no overload matches 'first_and_last' with type Int32
Overloads are:
 - first_and_last(arr : Array(U))

  first_and_last(42)
  ^~~~~~~~~~~~~~

Yes, it's still an error, but this time it's happening before you release your code. Catching bugs early is a wonderful thing.

Type Declaration in Crystal

You've seen a little of how types are declared in Crystal, now let's look at some more examples. Types are almost always declared in the following way:

# var_name : Type
arr  : Array(Int32)         = [1, 2, 3]
str  : String               = "Hello, world!"
int  : Int32                = 42
hash : Hash(String, String) = {"user" => "watzon"}

Like with Ruby, everything in Crystal is an Object and all Objects are valid Types, so custom classes, structs, etc. are also valid types. Now, there is another way to declare a type when it comes to Hashes and Arrays.

arr : Int32
arr = [] of Int32            # Assigning type declaration

hsh : Hash(String, String)
hsh = {} of String => String # Assigning type declaration

With most types (Int, String, Class) you can just assign the object to a variable without explicitly declaring the type. This is called type inference and it's extremely handy. You can do the same with Arrays and Hashes as well, provided they contain data, but if they're empty as in the previous example you will have to explicitly declare the type of the Array or Hash.

Type Inference

Type inference is a handy feature that almost gives the appearance of dynamic typing... sometimes. Let's use our first example again.

def first_and_last(arr : Array(U)) forall U
  if arr.size > 0
    return [arr.first, arr.last]
  end

  [] of U
end

Because we explicitly declare that the parameter arr is an Array we know that that parameter will have several helpful methods that allow us to act on the data stored in the Array. Array, however, is not the only class to contain many of those methods. There are other enumerable classes in Crystal that have #size, #first, and #last methods such as Set and Deque. Currently though, you could not use any of those classes in our first_and_last method. You could of course do this:

def first_and_last(arr : Indexable(U)) forall U
  if arr.size > 0
    return [arr.first, arr.last]
  end

  [] of U
end

Now any class that includes the Indexable module can be passed into first_and_last, but there is an easier, albeit less explicit way to handle things.

def first_and_last(arr)
  if arr.size > 0
    return [arr.first, arr.last]
  end

  arr
end

But wait, where did the types go? They're still there don't worry, but now instead of you having to explicitly declare the type of the parameter arr the compiler will infer the type based on what operations you perform on it. There are several classes that have #first, #last, and #size methods, and now all of them are valid inputs.

Union Types

One very powerful aspect of Crystal's type system is the ability to create type "unions". Here is an example of a union type.

arr = [] of Int32 | String

The pipe | operator creates a union between two types, allowing you to use either both Int32 and String types in that array. How awesome is that? Union types can also be generated dynamically by the compiler.

arr = ["Age", 32]

The variable arr in this case would be assigned the type Array(String, Int32) by the compiler. This also, of course, means that any operations performed on the data in the array have to check the type of the item before doing anything, unless they are doing something that is applicable to both types. For example:

arr = ["Age", 32]
arr.map { |a| a.chars }

chars is a method that exists on the String class and returns an array of all the characters in the String. The method does not, however, exist on the Int32 class. Because of that this code will not compile. Instead you'd have to do something like the following:

arr = ["Age", 32]
arr.map { |a| a.chars if a.is_a?(String) }

Things can definitely get messy when dealing with unions, so keep that in mind.

Conclusion

Crystal's type system is very powerful and I've really only scratched the surface. If you want to learn more about it I'd suggest looking at the Crystal reference.

Please don’t forget to hit one of the the Ego Booster buttons (personally I like the unicorn), and if you feel so inclined share this to social media. If you share to twitter be sure to tag me at @_watzon.

Some helpful links:
https://crystal-lang.org/
https://github.com/kostya/benchmarks
https://github.com/kostya/crystal-benchmarks-game
https://github.com/crystal-lang/crystal

Find me online:
https://medium.com/@watzon
https://twitter.com/_watzon
https://github.com/watzon
https://watzon.tech

Doing Crystal #2: Getting started with Crystal

Chris Watson — Wed, 22 May 2019 04:29:21 +0000

Hello and welcome to another edition of Doing Crystal. In this article I’m going do a brief overview of the installation of Crystal, Crystal Shards, using the CLI, and setting up a new project.

If you haven’t yet read the first part of this series you can check it out here.

Crystal is pretty easy to install, but sometimes there are hangups. As the language has matured (remember, it is only a 5 year old language) the installation process has gotten simpler and more OS’s are now supported than before. That being said, here are some things to keep in mind:

Windows Support

This is probably the biggest hangup for a lot of people just getting started with Crystal. As of the writing of this article, Windows is not supported by Crystal. There are ongoing efforts to port the compiler and make compiling on Windows possible, but for now you have 2 options if you want to get started with Crystal on Windows.

Install Linux. You can dual boot, use a VM, or just get rid of Windows all together, but Linux is definitely the best way to develop with Crystal.
Use WSL. This is still using Linux technically, but a little easier. WSL (or the Windows Subsystem for Linux) is a native kernel compatibility layer that allows you to run real Linux inside of Windows. The one hangup here is editor support, which I tried to mitigate with my project wsl-proxy. Support for WSL has also been added to the Crystal Language plugin for VS Code.

Compiling from Source

Compiling from the source files can be quite difficult if you don’t know what you’re doing. There are several libraries that are required before you can build the compiler. On systems for which there are instructions, namely Ubuntu, Fedora, and OS X, it’s pretty easy to download and install the libraries you need, but for systems such as Arch or Alpine Linux finding the correct libraries can be a little more difficult.

Luckily help is literally a click away.

General installation instructions are located at crystal-lang.org/reference/installation.

Shards

Ruby has Bundler, NodeJS has NPM, Rust has Cargo, and Crystal has Shards. Shards is a package manager and, like Crystal itself, is still in its infancy. That being said Shards is good at what it does: fetching and installing external Crystal libraries from a git repository.

Shards should come pre-packaged with Crystal. To check if you have it installed, run shards --help.

If you have shards installed and it is correctly referenced on your PATH you should see this output. The available commands are as follows:

build — the build command checks your shard.yml for binary definitions and builds them if any exist. You can use the [targets] option to build specific targets.
check— checks that your dependencies are up to date.
init — generates a shard.yml file in the current directory.
install — installs dependencies listed in your shard.yml.
list — lists installed shards.
prune — removes installed shards that are no longer needed.
update — updates shards.
version — gets the version of a project.

Unfortunately, installing binary shards (like you can with gem install [gemname] in Ruby) is not yet supported, but hopefully someday it will be.

The Crystal CLI

The Crystal CLI is an interface to the compiler, the Crystal Playground, tools, documentation generation, test running, and more. First run crystal --help to see if you have it installed correctly.

If you see this then you’re good to go. Let’s review the CLI’s commands.

init— Generates a new Crystal project. You can use crystal init lib [name] to generate a library project, or crystal init app [name] to generate a binary project.
build — builds a file. In most cases you’ll run crystal build ./src/project-name.cr, where project-name.cr is the main file that was generated for you when you ran crystal init.
docs — Crystal comes with a built in documentation generator. Personally I feel like there’s a lot missing where documentation generation is concerned, but you can pretty easily generate docs using your comments and type definitions just by running crystal docs.
env — prints the environment information for Crystal. ENV vars include CRYSTAL_CACHE_DIR, CRYSTAL_PATH, CRYSTAL_VERSION, and CRYSTAL_LIBRARY_PATH.
eval — evaluates and runs Crystal code from the standard input.
play — starts a local Crystal Playground server. This is somewhat like the playground located at https://play.crystal-lang.org/.
run — builds and runs the supplied filename. Use like crystal run [file].
spec — builds and runs specs located in the /spec directory.
tool — runs one of the available Crystal tools. Available tools are context, expand, format, hierarchy, implementations, and types.

Now that we’ve gone over the CLI a little, let’s set up a new project.

Creating a Project

Because it’s been deemed mandatory by the coding gods, let’s create a hello world application.

First let’s open up our terminal of choice and cd into a projects directory. In my case I’ll run cd ~/Projects. Using the CLI, we’re going to generate a new project scaffold, and then cd into our newly created project.

If you run ls you should see the following output:

The important files here are shard.yml and src/hello_world.cr. First let’s take a look at shard.yml.

I won’t go over this in detail, as most items should be self explanitory. If you need help with the available options in shard.yml you can look at the spec here.

Let’s open our main file located at src/hello_world.cr.

This is the boilerplate content generated for all new Crystal projects. As you can see our project name of hello_world has been PascalCased for the name of the base module. As a convention Crystal uses snake_case for project names, method names, variable names, etc. and PascalCase for constants such as module names and class names.

Now, as convention dictates our hello world application must print something like “Hello, World!” to the console, so let’s make it happen.

For the sake of this example we’ll be a little more verbose than we have to.

First we create a new class method in the HelloWorld module called say_hello. You can differentiate class and instance methods by looking for the self. syntax. def self.say_hello makes a class method, where def say_hello makes an instance method.

Our say_hello method takes one argument “name” which is assigned a default value of “World”. If we were to run say_hello without any arguments the default value of “World” would be used.

Next we go outside of the HelloWorld module to run our new method. As say_hello is an instance method we can call it with HelloWorld.say_hello. Class methods can not be used directly on modules as modules cannot be instantiated.

We finish things off by calling HelloWorld.say_hello("Manas") to give a shoutout to the people at Manas Tech who created Crystal.

Let’s run our program and see the output.

The program will take a few seconds to run as it has to compile first, but you should be greeted with a “Hello, Manas!”. Congratulations! You have written your first Crystal program. Replace run with build to build a binary to your current directory.

Conclusion

Crystal is an extremely powerful language and we’ve only scratched the surface so far. Next time we’ll discuss one of the many things that makes Crystal so powerful, it’s type system.

Please don’t forget to hit the Ego Booster button that looks like someone clapping, and if you feel so inclined share this to social media. If you share to twitter be sure to tag me at @_watzon.

Some helpful links:

https://crystal-lang.org/

https://github.com/kostya/benchmarks

https://github.com/kostya/crystal-benchmarks-game

https://github.com/crystal-lang/crystal

Find me online:

https://medium.com/@watzon

https://twitter.com/_watzon

https://github.com/watzon

https://watzon.me

Doing Crystal #1: A Ruby Comparison

Chris Watson — Wed, 22 May 2019 04:17:26 +0000

Hello world, and welcome to this series of blog posts which I'm titling "Doing Crystal". Yes it is a meth joke, and yes you'd better have a sense of humor if you're going to be a part of this series. You've been warned.

In this series of blog posts I will walk you through the beautiful world of Crystal, or as I like to call it, Ruby's over achieving younger sibling. If you haven't ever had a run in with Crystal then you're in for a treat, so sit down, buckle up, and enjoy the ride, Buttercup.

So what is Crystal? Crystal is a statically typed, compiled, garbage collected language with a syntax that is hauntingly familiar to anyone that has ever touched Ruby. It uses LLVM to compile your beautiful Ruby-esque code down to machine code, and in benchmarks is consistently much closer in speed to C++ than Ruby. Crystal development started in 2014, so it is about 20 years younger than Ruby and still in pre-release status at the writing of this article, but that doesn't mean you shouldn't pay attention to it. On the contrary I think that Crystal has amazing potential.

But if it's so much faster than Ruby, is a comparison really fair? Sure it is! I want to show you how you can take code that looks like Ruby and make it type-safe and make it 44x faster (based on the ). The Ruby ecosystem is still much more developed with 152,000 available Ruby gems as opposed to just over 4,000 Crystal shards, but such is to be expected from languages that are 20 years apart.

So, without further ado, let's get down to business and compare these two amazing languages.

Crystal vs Ruby

First let's start with what a lot of people, me included, consider the most important piece of any programming language. The syntax. Sure speed is nice and everything, but if your fast code ends up looking like a steaming pile of cow dung (I'm looking at you C++) then the maintainability factor for your project goes way down.

Let's start with an example from the Crystal lang website, a super simple HTTP server.

First the Ruby sample:

Creating a HTTP server in Ruby is interesting. It's not at all intuitive and makes life kind of difficult. Yes, in Ruby you can also just use Sinatra or any other gem to create a server, but this example is about doing it in pure Ruby.

Now for Crystal:

Wait, that's it? How simple is that. You import from http/server instead of socket, you use a block to handle the looping and the block hands you a context. There's no blocking loop, no need to manually define headers, and no real complexity.

Ok so some API's are simplified, but what about this static typing? Let's take look at another couple examples.

First the Ruby code:

Now sure, any good Ruby dev would do a type check in the sum method to make sure that only integers are accepted, but that's extra work and even the best devs can miss things.

How about some Crystal:

This still throws an error, but the difference is when. A compile error is much better than a runtime error, because runtime errors are usually caught by the end-user. The error thrown is:

no overload matches 'Int32#+' with type (Int32 | String)
Overloads are:
 - Int32#+(other : Int8)
 - Int32#+(other : Int16)
 - Int32#+(other : Int32)
 - Int32#+(other : Int64)
 - Int32#+(other : Int128)
 - Int32#+(other : UInt8)
 - Int32#+(other : UInt16)
 - Int32#+(other : UInt32)
 - Int32#+(other : UInt64)
 - Int32#+(other : UInt128)
 - Int32#+(other : Float32)
 - Int32#+(other : Float64)
 - Number#+()
Couldn't find overloads for these types:
 - Int32#+(String)
arr.reduce(0) { |acc,i| acc + i }
                              ^

As you can see, not only does it throw an error, but it tells you exactly what the problem is. In this case the problem is that you can't add an integer to a string, even a string that has an integer in it.

And now you see some of Crystal's extremely powerful type system. All things in Crystal are typed, from Arrays to Hashes to variables. Because of this type safety the compiler absolutely will not allow you to make mistakes where types are concerned, and that means that runtime errors are basically nonexistent.

Now I'm not saying that you can't make mistakes in Crystal. You can still do stupid things like creating an infinite loop, and stack overflows aren't nonexistent. Crystal is still pre-release software after all. But the amount of safety you get from Crystal as opposed to Ruby is astounding.

That's it for this edition of Doing Crystal. Please remember to like, share, and subscribe, because yes, this is secretly a YouTube video and your life is a lie.

View the next post in this series here.

Some helpful links:
https://crystal-lang.org/
https://github.com/kostya/benchmarks
https://github.com/kostya/crystal-benchmarks-game
https://github.com/crystal-lang/crystal
Find me online:
https://medium.com/@watzon
https://twitter.com/chrystal_coder
https://github.com/watzon
https://watzon.me