​​#k8s #devops #go

arkade (ark for short) provides a clean CLI with strongly-typed flags to install charts and apps to your cluster in one command.

Gone are the days of contending with dozens of README files just to get the right version of #helm and to install a chart with sane defaults.

https://github.com/alexellis/arkade

​​#k8s #devops #go

Local Kubernetes development with no stress.

Tilt helps you develop your microservices locally. Run tilt up to start working on your services in a complete dev environment configured for your team.

Tilt watches your files for edits, automatically builds your container images, and applies any changes to bring your environment up-to-date in real-time. Think docker build && kubectl apply or docker-compose up.

https://github.com/windmilleng/tilt

Turn real code (Github Gist)
into faux code (SVG image)

http://knutsynstad.com/fauxcode/

#js

​​Napkin is a tool to "write" sequence diagrams effectively as #python code.

https://github.com/pinetr2e/napkin

This code:

def distributed_control(c):
    user = c.object('User')
    order = c.object('Order')
    orderLine = c.object('OrderLine')
    product = c.object('Product')
    customer = c.object('Customer')

    with user:
        with order.calculatePrice():
            with orderLine.calculatePrice():
                product.getPrice('quantity:number')
                with customer.getDiscountedValue(order):
                    order.getBaseValue().ret('value')
                    c.ret('discountedValue')

Will result in:

Great read about #scala's ZLayer from ZIO.

Nice and very useful concept that can be ported to many other languages.

https://zio.dev/docs/howto/howto_use_layers

​​Performance analysis toolkit for #csharp

Perfolizer is a collection of useful algorithms for performance analysis. You can use it as a NuGet package or via a command-line tool.

Perfolizer is used as a statistical engine for BenchmarkDotNet (the most popular .NET library for benchmarking).

https://github.com/AndreyAkinshin/perfolizer

fs-err is a drop-in replacement for #rust std::fs that provides more helpful messages on errors. Extra information includes which operations was attmpted and any involved paths.

The error message that Rust gives you isn't very useful: The system cannot find the file specified. (os error 2)

...but if we use fs-err instead, our error contains more actionable information:

 to open file `does not exist.txt`
    caused by: The system cannot find the file specified. (os error 2)

https://github.com/andrewhickman/fs-err

​​Linkalot is a web-based inbox for your links.

Linkalot’s highlights:

- Instantly save links in a link list using the accompanying bookmarklet.
- Add a short description to a link. The description appears as a pop-up on hover.
- All links are saved in a plain text file.
- Password-protected editing area for managing the saved links.

Repo: https://gitlab.com/dmpop/linkalot
Demo: https://tokyoma.de/linkalot/

#php

​​Design tokens at your fingertips.

Classy-UI is CSS properties abstracted to design tokens. This abstraction does not only make your design consistent, but also discoverable and documented at your fingertips in the IDE.

Features:

- No runtime in production
- The application starts without a single line of CSS. Based on the API usage Classy-UI will automatically generate the CSS they represent
- Add decorators (pseudo selectors and media queries) directly on your tokens, and again Classy-UI will automatically build the necessary CSS
- Classy-UI completely gets rid of specificity issues
- When you write tokens you can search them right in the code. You also get documentation of what CSS the token produces, even without Typescript
- An excellent developer experience as your IDE writes the tokens for you, you just select them from the intellisense
- If you use invalid tokens Classy-UI will yell at you
- When adding themes that overrides tokens, they automatically become CSS variables
- In production Classy-UI will shorten all the CSS classnames, group media queries and themes, creating a highly optimized bundle

https://classy-ui.io/

#js #css #html

Useful example about #ddd for #haskell

It explains some of the philosophies behind using ValidateT, persistent & polysemy as the impl artifacts of various DDD principles in a purely functional setting.

​​> It has been over 4 years since I last wrote #csharp, and being exposed to functional programming clearly affected how I write code today. The snippet I wrote seems very neat and natural, however, some people expressed concerns that it doesn’t feel like C# code — “It looks too functional.“

Great article about writing simple and readable code in any language.

​​MixAudit provides a mix deps.audit task to scan a project Mix dependencies for known #elixir security vulnerabilities.

https://github.com/mirego/mix_audit

> Almost every week I accidentally get into this logging argument. Here’s the problem: people tend to log different things and call it a best-practice. And I am not sure why. When I start discussing this with other people I always end up repeating the exact same ideas over and over again.

> So. Today I want to criticize the whole logging culture and provide a bunch of alternatives.

#rant #devops

> There’s a little-known pattern in software architecture that deserves more attention: data-oriented architecture.

> DOA is an inversion of the traditional dichotomy between a monolithic binary and data store (monolithic architecture) on the one hand, and small, distributed, independent binaries each with their own data stores (microservices, and service-oriented architecture) on the other.

> In data-oriented architecture, a monolithic data store is the sole source of state in the system, which is being acted on by loosely-coupled, stateless microservices.

#architecture

​​> Clear Your Terminal in Style
> If you’re someone like me who habitually clears their terminal, sometimes you want a little excitement in your life. Here is a way to do just that.

Here's the example from Matrix. There are many more inside!

#cli

​​Daat is an experimental library meant to provide parameterized modules to #elixir.

Imagine that you have a module named UserService, that exposes a function named follow/2. When called, the system sends an email to the user being followed. It would be nice if we could extract actually sending the email from this module, so that we aren't coupling ourselves to a specific email client, and so that we can inject mocks into the service for testing purposes.

By using parameterized, or higher-order modules, we can instead define a module that specifies an interface, and acts as a generator for modules of that interface. By then passing our dependencies to this generator, we are able to dynamically create new modules that implement our desired behaviour.

https://github.com/QuinnWilton/daat

​​SHML is a #shell framework for faster and easier script development. HTML has CSS, terminals have "ANSI/VT100 Control Sequences". SHML makes is easy to apply some style to your shell scripts without trying to remember that Yellow = \033[33m instead Yellow is $(color yellow).

https://github.com/odb/shml

​​Find open-source alternatives for your favorite apps.

https://opensource.builders/

​​Enforceable standards for your package.json scripts – like eslint for npm run!

package.json scripts are an integral part of the Node dev experience: we use them to start our projects, run our dev environments and for all kinds of formatting, linting and tooling in general. They are just as important as our code. Yet we don't treat them with the same meticulous attention to detail. Scripts need ❤️ too!

One of the main goals for scriptlint was to enable people to use memorable and consistent script names across their projects. Tools like nps are great when you have to organize scripts with a certain level of complexity, but they don't help you with the structure and naming of your scripts.

This is where the scriptlint CLI shines: it makes best practices outlined in this documentation enforceable throughout your project(s). Think of it as eslint for your "scripts" section.

https://github.com/peerigon/scriptlint

#ts #js

​​Bringing full-stack to the JAMstack

Do you love the JAMstack philosophy but need a database-backed web app? Want great developer experience and easy scaling? Redwood is here! Built on #react, GraphQL, and Prisma, Redwood works with the components and development workflow you love, but with simple conventions and helpers to make your experience even better.

https://redwoodjs.com/

It also includes React Single File components: https://www.swyx.io/writing/react-sfcs-here/

#ts #js