Reaktor, a Finnish software consultancy, publishes engineering posts on JavaScript, types, functional programming, and Amiga assembly.
HN commenters mostly link it in job postings and praise its Finnish-style benefits, such as four weeks of vacation and limited overtime.
For anybody who found this interesting, make sure to read his earlier article (which he links to) here: http://reaktor.com/blog/why-csp-matters-i-keeping-things-in-sync/ . It sets up the problem which he then answers in this post.
We've been having a similar issue, where we want to make sure our data syncs correctly. One of our contributors built this ToDoMVC app http://todos.loqali.com/ (which basically also works for a grocery list app as well), but how do you know it synced correctly? Or more importantly, how do you prove it?
The article is great at addressing this with clojure and and CSP. But it would be nice if we had a generic testing framework (like Jasmine, Mocha, etc. are) for doing this. That is why one of my employees is working on https://github.com/gundb/panic (in development! not working yet!). So far it has been specific to our project, but this next iteration he is splitting it out and making it generic to any project.
You write your test, it gets deployed on a bunch of clients/peers, and then the test coordinator (panic) aggregates the results and confirms if everything ran correctly or not. The cool thing is since your test is deployed across a bunch of peers, you can have the test assert that client1 received an update from client2 - if that never fulfills, then it is considered a "fail". If however, a non-deterministic network hiccup occurs (versus a simulated one in the test), the whole test suite should bail and force you to re-run so you don't get…
I've prototyped UIs with RxJS (the javascript version of reactive extensions) both by itself and with Cycle.js. I've also used reactive programming in Perl 6. There are a lot of things to like about reactive programming, but anymore I'm not sure if it's the right answer. Let me first preface this by saying that I'm building upon thoughts presented (by someone else) here: http://blog.paralleluniverse.co/2015/08/07/scoped-continuations/
One problem with reactive programming (and also with promises), is that you are essentially using monadic composition in an imperative language. Because of the lack of special support for monads that you have in a language like Haskell, you have.to.chain.flow.control.methods. As a result of this, you lose access to the standard flow control the imperative language provides you, and you also generally end up with mangled stack traces. Now I know that rxjs5 is working on the stack trace problem through the usage of a recursive scheduler, but I'm not sure how this works on the Java side of things.
An alternative approach can be found in languages like Go and Erlang. In these languages you generally do not need to worry about exhausting a thread pool because they have made creating "threads" extremely cheap. As such, you can write normal imperative code that blocks, potentially indefinitely, and also still preserves stack traces and which uses the plain flow control structures (and error handling) of imperative programming.
Furthermore, if you…
Reaktor | New York City | Full-time | Senior Software Engineer| https://www.reaktor.com/careers/senior-software-engineer/
Reaktor is a strategy, design, and engineering company based in NYC, Helsinki, Tokyo and Amsterdam. Our New York office is growing fast and we’re always on the look-out for the most talented software engineers to make sure our teams are filled with best in class individuals. We might all have climbed far up the career ladder in our past lives, but here we leave our titles at the door and work together to get shit done with clients like HBO, Michael Kors, Nasdaq, Samsung, Supercell, and Finnair.
Here’s what we can offer you:
- Teams that are totally autonomous and cross-functional.
- A community of amazing people who will both teach you and learn from you.
- Experimentation and continuous improvement of our skills and ways of working.
- A commitment to constant evolution (and the occasional revolution).
- A world without hierarchy—big ideas can come from anyone and anywhere.
- A ton of fun!
What We’ll Expect From You:
- A ton of skills and wisdom in working with tech that you consider useful. In no particular order, here are some things many of us like: functional programming, Node.js, Clojure, React, Swift, SQL, NoSQL, general bleeding edge stuff.
- Passion for:
- Agile and lean principles that actually work – not rituals for rituals’ sake.
- Solving really hard problems (and doing it with clean code).
- Learning, growing, and…
Other are not wrong in saying Memory mapped IO. taking a look at the Amiga hardware Reference manual [1] and a simple example [2] or a NES programming guide [3] would be a good way to see this in operation.
A more modern CPU/GPU setup is likely to use a ring buffer. The buffer will be in CPU memory. That memory is also mapped into the GPU address space. The Driver on the CPU will write commands into the buffer which the GPU will execute. These will be different to the shader unit instruction set.
Commands would be setting some internal GPU register to a value. Allowing the setting resolution, framebuffer base pointer, set up the output resolution, setting the mouse pointer position, reference a texture from system memory, load a shader, execute a shader, set a fence value (Useful for seeing when a resource, texture, shader is no longer in use).
Hierarchical DMA buffers are a useful feature of some DMA engines. You can think of them as similar to sub routines. The command buffer can contain an instruction to switch execution to another chunk of memory. This allows the driver to reuse operations or expensive to generate sequences. OpenGL's display list commonly compiled down to separate buffer.
[1] https://archive.org/details/amiga-hardware-reference-manual-3rd-edition
[2] https://www.reaktor.com/blog/crash-course-to-amiga-assembly-programming/
[3] https://www.nesdev.org/wiki/Programming_guide
Reaktor | Software Developer, from World to Amsterdam | VISA, ONSITE
We: engineering and design company, located in Amsterdam, 12 nationalities strong, 18 years old. You: a gifted developer, not necessarily located in Amsterdam, whatever nationality or age, interested in seeing what the land of tulips has to offer.
Reaktor is looking for software developers to join our team in Amsterdam – wherever you might be living now.
From day one, our growth philosophy has been to hire any and all Reaktorians out there. In order to help newcomers from abroad ease into Dutch life as smoothly as possible, we have now published our very own Relocation Guide: https://relocate-to-amsterdam.reaktor.com
What we expect from you:
– A ton of skill and wisdom in working with tech that you consider useful. In no particular order, here are some things many of us like: functional programming, Node.js, Clojure, React, Swift, SQL, NoSQL, general bleeding edge stuff
– Ability to read and speak English fluently and idiomatically
– Appreciation for agile and lean principles that actually work, and solving really hard problems with clean code
– Willingness to be responsible for your work, development and career path
What we’re offering to you: https://www.reaktor.com/careers/software-developer-from-world-to-amsterdam/
(All open roles: reaktor.com/careers/amsterdam)
Drop us a line: careers-nl@reaktor.com. <3
Reaktor | iOS Developer | Amsterdam, Netherlands | Visa + relocation | https://www.reaktor.com
More information and application: https://www.reaktor.com/careers/ios-developer-amsterdam/
At Reaktor, we design and build tomorrow’s digital products. We are known for our flat hierarchy, have a 5-star Glassdoor rating, and launched a satellite running Node.js in low Earth orbit.
The Amsterdam office has a unique vibe, being a lively mix of 20 nationalities. From day one, our growth philosophy has been to hire any and all Reaktorians out there. This has served us well, with a welcoming community of humans who will connect with you beyond the day-to-day.
Ideally you…
- Know how to write decoupled, easy to maintain and testable code in Swift.
- View your colleagues and clients as individuals with their respective strengths and weaknesses.
- Can work with the team to decide the best tools for the job at hand. Sometimes RxSwift is your best friend, and other times React Native suits a project better.
- Enjoy working with juniors and seniors on the shiny and dirty bits of a project. You might help out developing microservices or APIs for an app every now and then.
- Have experience publishing iOS apps to the App Store.
- Appreciate the fine details of visuals, user interaction, animations, and everything else that makes an app not just work but feel great as well.