We use a client/server architecture where Figma clients are web pages that talk with a cluster of servers over WebSockets. Our servers currently spin up a separate process for each multiplayer document which everyone editing that document connects to

CRDTs are designed for decentralized systems where there is no single central authority to decide what the final state should be. There is some unavoidable performance and memory overhead with doing this. Since Figma is centralized (our server is the central authority), we can simplify our system by removing this extra overhead and benefit from a faster and leaner implementation

Write a new test and the result. If you want to make it REPL-like, instead of writing console.log(x.toString()) use expect(x.toString()).toBe('') and you will directly get the result.

interactive notebooks fall short when you want to write bigger, maintainable code

I recommend Airbnb style JavaScript style guide and Airbnb TypeScript)

Creating meticulous tests before exploring the data is a big mistake, and will result in a well-crafted garbage-in, garbage-out pipeline. We need an environment flexible enough to encourage experiments, especially in the initial place.

Language tooling is richer today. A programming language was usually a compiler and perhaps a debugger. Today, they usually come with the linter, source code formatter, template creators, self-update ability and a list of arguments that you can use in a debate against the competing language.

There is StackOverflow which simply didn’t exist back then. Asking a programming question involved talking to your colleagues.

Since we have much faster CPUs now, numerical calculations are done in Python which is much slower than Fortran. So numerical calculations basically take the same amount of time as they did 20 years ago.

According to PEP 8, comments should have a maximum length of 72 characters.

use `multiple line comment`

Docstring conventions are described within PEP 257. Their purpose is to provide your users with a brief overview of the object.

All multi-lined docstrings have the following parts: A one-line summary line A blank line proceeding the summary Any further elaboration for the docstring Another blank line

"""This is the summary line

This is the further elaboration of the docstring. Within this section,
you can elaborate further on details as appropriate for the situation.
Notice that the summary and the elaboration is separated by a blank new
line.

# Notice the blank line above. Code should continue on this line.

say_hello.__doc__ = "A simple function that says hello... Richie style"

def say_hello(name):
    print(f"Hello {name}, is it me you're looking for?")

say_hello.__doc__ = "A simple function that says hello... Richie style"

def say_hello(name):
    """A simple function that says hello... Richie style"""
    print(f"Hello {name}, is it me you're looking for?")

>>> help(say_hello)

Help on function say_hello in module __main__:

say_hello(name)
    A simple function that says hello... Richie style

class constructor parameters should be documented within the __init__ class method docstring

Scripts are considered to be single file executables run from the console. Docstrings for scripts are placed at the top of the file and should be documented well enough for users to be able to have a sufficient understanding of how to use the script.

Documenting your code, especially large projects, can be daunting. Thankfully there are some tools out and references to get you started

Commenting your code serves multiple purposes

In general, commenting is describing your code to/for developers. The intended main audience is the maintainers and developers of the Python code. In conjunction with well-written code, comments help to guide the reader to better understand your code and its purpose and design

Along with these tools, there are some additional tutorials, videos, and articles that can be useful when you are documenting your project

If you use argparse, then you can omit parameter-specific documentation, assuming it’s correctly been documented within the help parameter of the argparser.parser.add_argument function. It is recommended to use the __doc__ for the description parameter within argparse.ArgumentParser’s constructor.

There are specific docstrings formats that can be used to help docstring parsers and users have a familiar and known format.

Daniele Procida gave a wonderful PyCon 2017 talk and subsequent blog post about documenting Python projects. He mentions that all projects should have the following four major sections to help you focus your work:

Since everything in Python is an object, you can examine the directory of the object using the dir() command

Documenting your Python code is all centered on docstrings. These are built-in strings that, when configured correctly, can help your users and yourself with your project’s documentation.

Along with docstrings, Python also has the built-in function help() that prints out the objects docstring to the console.

The general layout of the project and its documentation should be as follows:

project_root/
│
├── project/  # Project source code
├── docs/
├── README
├── HOW_TO_CONTRIBUTE
├── CODE_OF_CONDUCT
├── examples.py

In all cases, the docstrings should use the triple-double quote (""") string format.

the developer doesn’t need to worry about allocating memory, or the character set encoding of the string, or a host of other things.

“No Code” systems are extremely good for putting together proofs-of-concept which can demonstrate the value of moving forward with development.

With someone else’s platform, you often end up needing to construct elaborate work-arounds for missing functionality, or indeed cannot implement a required feature at all.

It is solved when you understand why it occurred and why it no longer does.

Machine Learning pipeline for our Sales Forecasting problem, and the 3 steps to automate it with DVC

Continuous Delivery for Machine Learning end-to-end process

common functional silos in large organizations can create barriers, stifling the ability to automate the end-to-end process of deploying ML applications to production

There are different types of testing that can be introduced in the ML workflow.

example of how to combine different test pyramids for data, model, and code in CD4ML

A deployment pipeline automates the process for getting software from version control into production, including all the stages, approvals, testing, and deployment to different environments

We chose to use GoCD as our Continuous Delivery tool, as it was built with the concept of pipelines as a first-class concern

Continuous Delivery for Machine Learning (CD4ML) is the discipline of bringing Continuous Delivery principles and practices to Machine Learning applications.

Development Pros Cons

This kind of “exploring” is easiest when you develop on the prompt (or REPL), or using a notebook-oriented development system like Jupyter Notebooks

notebook contains an actual running Python interpreter instance that you’re fully in control of. So Jupyter can provide auto-completions, parameter lists, and context-sensitive documentation based on the actual state of your code

They switch to get features like good doc lookup, good syntax highlighting, integration with unit tests, and (critically!) the ability to produce final, distributable source code files, as opposed to notebooks or REPL histories

Exploratory programming is based on the observation that most of us spend most of our time as coders exploring and experimenting

Frontend Devs: What should I learn after JavaScript? Explore these frameworks and libraries

The best way to explain the difference between launch and attach is to think of a launch configuration as a recipe for how to start your app in debug mode before VS Code attaches to it, while an attach configuration is a recipe for how to connect VS Code's debugger to an app or process that's already running.

Logpoint is a variant of a breakpoint that does not "break" into the debugger but instead logs a message to the console. Logpoints are especially useful for injecting logging while debugging production servers that cannot be paused or stopped. A Logpoint is represented by a "diamond" shaped icon. Log messages are plain text but can include expressions to be evaluated within curly braces ('{}').

Here are some optional attributes available to all launch configurations

The following attributes are mandatory for every launch configuration

Many debuggers support some of the following attributes

Version control is at the heart of any modern engineering org. The ability for multiple engineers to asynchronously contribute to a codebase is crucial—and with notebooks, it’s very hard.

The priorities in building a production machine learning pipeline—the series of steps that take you from raw data to product—are not fundamentally different from those of general software engineering.

Reproducibility is an issue with notebooks. Because of the hidden state and the potential for arbitrary execution order, generating a result in a notebook isn’t always as simple as clicking “Run All.”

A notebook, at a very basic level, is just a bunch of JSON that references blocks of code and the order in which they should be executed.But notebooks prioritize presentation and interactivity at the expense of reproducibility. YAML is the other side of that coin, ignoring presentation in favor of simplicity and reproducibility—making it much better for production.

Notebook files, however, are essentially giant JSON documents that contain the base-64 encoding of images and binary data. For a complex notebook, it would be extremely hard for anyone to read through a plaintext diff and draw meaningful conclusions—a lot of it would just be rearranged JSON and unintelligible blocks of base-64.

There is no hidden state or arbitrary execution order in a YAML file, and any changes you make to it can easily be tracked by Git

Python unit testing libraries, like unittest, can be used within a notebook, but standard CI/CD tooling has trouble dealing with notebooks for the same reasons that notebook diffs are hard to read.

Use camelCase when naming objects, functions, and instances.

const thisIsMyFuction() {}

Use PascalCase only when naming constructors or classes.

// good
class User {
  constructor(options) {
    this.name = options.name;
  }
}

const good = new User({
  name: 'yup',
});

Use uppercase only in constants.

export const API_KEY = 'SOMEKEY';

Let's replicate our inefficientSquare example, but this time we'll use our memoizer to cache results.

The biggest problem with JSON.stringify is that it doesn't serialize certain inputs, like functions and Symbols (and anything you wouldn't find in JSON).

Memoization is an optimization technique used in many programming languages to reduce the number of redundant, expensive function calls. This is done by caching the return value of a function based on its inputs.

If you'd just like to see refactorings without Quick Fixes, you can use the Refactor command (Ctrl+Shift+R).

Stary, dobry Uncle Bob mówi, że poza etatem trzeba na programowanie poświęcić 20h tygodniowo.Gdy podzielimy to na 7 dni w tygodniu, to wychodzi prawie 3 godziny dziennie.Dla jednych mało, dla innych dużo.

This type relation is sometimes written S <: T

subtyping allows a function to be written to take an object of a certain type T, but also work correctly, if passed an object that belongs to a type S that is a subtype of T (according to the Liskov substitution principle)

chose the term ad hoc polymorphism to refer to polymorphic functions that can be applied to arguments of different types, but that behave differently depending on the type of the argument to which they are applied (also known as function overloading or operator overloading)

I strongly suggest to anyone who wants to become a developer that they do it as well. I mean, it's really easy to see all the work that's out there, and all the things that are left to learn, and think that it's just way beyond you. But when you write it down, you have a place that you can go back to, and not only have I been able to help other people with my blog posts, but I help myself. I'm constantly Googling something and getting my own website in response, and like, oh yeah, I remember I did that before.

it pollutes the MultiDelegator class with every new delegate. If you use MultiDelegator several times, it will keep adding methods to the class, which is undesirable

The handler can be a method or a Proc object passed to the :with option. You can also use a block directly instead of an explicit Proc object.

Our Cookie Solution plugins for WordPress, Magento, Joomla! and PrestaShop allow you to automate the blocking of scripts drastically reducing the necessity for direct interventions in the site’s code.

A NackClass is the same as NilClass except for any method it does not recognize, it return the instance of itself. nack.nack.nack.nack #=> nack Note I used to call this NullClass, but "nack" seems a little more fitting a term.

To be just a bit polemic, your first instinct was not to do that. And you probably wouldn't think of that in your unit tests either (the holy grail of dynamic langs). So someday it would blow up at runtime, and THEN you'd add that safeguard.

You can just leave your website at that address (it'll give you some serious street cred in the developer world), but if you have a custom domain you would like to use, it is very simple to make GitHub redirect your page. Log in to your domain registrar and find where to change your host records. If you don't know, you can usually Google "(domain registrar) change host records", and your registrar will have an explainer telling you how to do it. Change your domain's A Record to 204.232.175.78. This is GitHub's IP address, which allows GitHub to resolve your URL and serve the correct files. In your website's directory folder on your computer, create a file called "CNAME". On the first line, type your domain name. Save the file. In your GitHub application, you should see the file in the left column. Make sure it is checked and enter your commit message. Have it say something like "Adding CNAME file." Click "Sync branches." It can take as long as 48 hours for your domain to resolve to your GitHub page. However, it is usually pretty quick, so check back in an hour or so.

Underneath that awkward Java-esque patina, JavaScript has always had a gorgeous heart.

Nix is a purely functional package manager. This means that it treats packages like values in purely functional programming languages such as Haskell — they are built by functions that don’t have side-effects, and they never change after they have been built.

Optimize imports

Larry Wall famously said he was driven to create Perl by how difficult it was to solve a problem while coding, as well as by an abundance of 'laziness, impatience and hubris'

the impetus may have been more the challenge of creating a language of his own.

To an outsider, creating your own programming language might seem akin to saying 'I'll build my own airplane

Environment variables are 'exported by default', making it easy to do silly things like sending database passwords to Airbrake.

This naming convention helps developers understand the component’s contract

Reason is not a new language; it's a new syntax and toolchain powered by the battle-tested language, OCaml.

We might have some dirty mutable objects for performance - but our high-level API should be purely functional. You should be able to follow the React model of modelling your UI as a pure function of application state -> UI.

the abstraction I wished to have was a sort of a pure functional Vim, completely decoupled from terminal UI - where 'vim' is a function of (editor state, input) => (new editor state)

enquo() uses some dark magic to look at the argument, see what the user typed, and return that value as a quosure

If you love Ruby, you'll enjoy CoffeeScript as it makes the JavaScript more like the Ruby.

In 2017, I rewrote it again as a ClojureScript application, and it was only 500 lines of code! Holy cow!!!

For example the following pattern: (let [x true y true z true] (match [x y z] [_ false true] 1 [false true _ ] 2 [_ _ false] 3 [_ _ true] 4)) ;=> 4 expands into something similar to the following: (cond (= y false) (cond (= z false) (let [] 3) (= z true) (let [] 1) :else (throw (java.lang.Exception. "No match found."))) (= y true) (cond (= x false) (let [] 2) :else (cond (= z false) 3 (= z true) 4 :else (throw (java.lang.Exception. "No match found.")))) :else (cond (= z false) (let [] 3) (= z true) (let [] 4) :else (throw (java.lang.Exception. "No match found.")))) Note that y gets tested first. Lazy pattern matching consistently gives compact decision trees. This means faster pattern matching. You can find out more in the top paper cited below.

reactions bridge reactive and imperative programming

The problem with the annotation notion is that it's the first time that we consider a piece of data which is not merely a projection of data already present in the message store: it is out-of-band data that needs to be stored somewhere.

many of the searches we want to do could be accomplished with a database that was nothing but a glorified set of hash tables

There are objects, sets of objects, and presentation tools. There is a presentation tool for each kind of object; and one for each kind of object set.

That said, most Clojure programs begin life as text files, and it is the task of the reader to parse the text and produce the data structure the compiler will see

Good general theory does not search for the maximum generality, but for the right generality.

I was so fed up of the mega amounts of boilerplate with Redux and the recommendation of keeping your data loading at view level. It seems to me that things like this, with components being responsible for their own data, is the way to go in the future.

Null Coalescing Operator

Entities are the applications, services, and files in the ARGON worldview

In 1947, a high-flying moth bumped into Harvard’s Mark II Aiken Relay Calculator, was removed by computer operator William Burke, and then taped to the computer log - popularizing the existing term “debugging.”Figure 4: debugging

Go Programming Language publicly in 2009 they were also looking to solve certain challenges of the existing Computer languages. Of the many features that it demonstrated (we will get to those soon enough) it was also helpful in addressing the strange dilemma of hardware and software that was emerging.

we process millions of transactions per day here and we really need someone with more relevant experience who can handle these things without ramping up

I want to stop putting comments in my code. I want it to be first-class for my code to be in the left pane and my comments to be in the right pane, always binded together with anchors but always separate so my comments don't have to adhere to the limitations of the code's text area.

(if (instance? Throwable ret)

:ok

(fn [system] (throw (ex-info "initializer not set, did you call `set-init`?" {}))))

The Women Who Contributed to Science but Were Buried in Footnotes

for example, comments and identifiers

If one object is part of another object, then we use a diamond at the start of the arrow (next to the containing object), and a normal arrow at the end.

Grid devices can be nested or layered along with other devices and your plug-ins,

after the terminal operation of the stream pipeline commences.