As I about my experience with Linux as my replacement for a Mac, here is my experience with developing web apps on Linux. promised to write more It’s almost ridiculous how easy web development on Linux is. All the are a simple “apt install” command away. If not, most vendors outline how to add their repository and then issue an “apt install” command. tools Thus, installing MongoDB, Elasticsearch and MySQL takes you literally a few minutes. Same applies to (my weapon of choice for web apps). You either have the option to get node from or which allows you to run different versions of node, e.g. if your production environment runs on node 4.x but you want to get ready for node 6.x. With nvm installed you can painlessly switch between versions with a single command, i.e. “nvm use 6” or “nvm use 4”. nodejs nodejs.org install nvm (node version manager) Also, for editing code you have a plethora of options. Some of those editors, are Linux only. Hence I’ll only list my experience with the ones that are available on macOS as well. VimPeople either love or hate vim. Personally, I love the power of vim, and I tend to use vim and sublime text together (Honestly, I sometimes get confused with all the shortcuts). On Linux I use vim more as it just works better. On the mac, it’s sometimes a bit a sluggish experience. Obviously, though with some tweaks, vim runs perfectly on Linux. Sublime Text 3This is my go-to editor. It’s extremely fast, comes with a lot of options and the vast amount of packages lets you tailor the editor for your needs. If vim is not your thing (I don’t blame you) then give Sublime Text 3 a chance. It really is one of the best editors out there. As Sublime Text 3 is available on Linux, Windows and macOS it’s quite easy to have the same environment setup on all of them. AtomI don’t know what it is, but I never really got the hang of Atom. Yes, it’s open source and it looks nice, but it is just so slow. Even on Linux, Atom is the slowest compared to vim and Sublime Text 3. Options are endless and there is a vibrant community and you can find just about any package. I’ve configured Atom to work the same as vim and Sublime Text 3, but I still use Sublime Text 3 and vim more. It’s a nice editor, but as mentioned, there is something that doesn’t work for me. So there you have it. Personally, I couldn’t be happier with using Linux for web development. is how hackers start their afternoons. We’re a part of the family. We are now and happy to opportunities. Hacker Noon @AMI accepting submissions discuss advertising &sponsorship To learn more, , , or simply, read our about page like/message us on Facebook tweet/DM @HackerNoon. If you enjoyed this story, we recommend reading our and . Until next time, don’t take the realities of the world for granted! latest tech stories trending tech stories

Facebook

From Mac to Linux: Web Development with Linux

This solution only works if NGINX and PHP-FPM both reside on the same server. Notice: A ‘git pull’ on a live server for deployments isn’t ideal since all files don’t change on the disk at the same millisecond. A request that starts on one version of the code might access other files which could be updated during the request. To get truly atomic deployments, PHP deployment applications like Capistrano have a symlink pointing to the current build and simply update the symlink to the new build once the new build folder is ready. Since Linux doesn’t itself have any disk cache, changing the symlink to point to the new build is atomic. At the same millisecond, all files in the symlinked folder now point to their newer versions. This build process has some issues. The setup: NGINX(the web server) and PHP-FPM(PHP FastCGI process manager) both reside on the same server. NGINX serves from the document root(/var/www/app.com) which is a symlink to the current build. Visitor requests Nginx proxies PHP-FPM and asks it to execute /var/www/app.com/hello.php. PHP-FPM returns output of the above script to NGINX and NGINX serves it back to the visitor. https://app.com/hello.php. PHP Opcache is a cache with maintains a mapping of (script path -> machine code translations). This cache prevents interpreting PHP code again and again and makes a lot of difference in performance. PHP’s Realpath Cache is a cache containing path mappings for relative file includes within PHP scripts. It also makes a lot of difference in performance if a lot of ‘require/require_once’ and ‘include/include_once’ statements are used in the scripts. The problem The last step in the build process is changing the symlink. On changing the symlink, FPM was still executing PHP scripts from the old build folder. Then came the realization. If NGINX tells PHP-FPM to execute /var/www/app.com/hello.php, Opcache would simply pick up the old machine translation for the script(since OpCache still gets the same path for the file) unless it’s cache is flushed. Opcache itself consults Realpath Cache for some path mappings. What if we could flush Opcache and Realpath cache Even if caches are flushed for both of these on each build, there would be some milliseconds between flushing of the cache and the symlink change. In this time in between, due to incoming requests on the server, the cache would again start on building and flushing the cache would be of no use. If the cache is flushed after making the symlink change, then old code would get executed in the time between flushing the cache and the symlink change. What if PHP-FPM is reloaded This itself had 2 issues: a) Some requests could drop/not complete/fail in the process of reloading. b) Again, there could be some milliseconds between making the symlink and start of reloading of FPM. Old code could get executed again in between that time since the symlink would already have been changed till then. Therefore, this clearly wasn’t a solution. What if NGINX serves from the new build folder(not the symlinked one) and is reloaded? NGINX can serve from the new build folder than the symlinked folder, therefore, removing all caching issues. The document root could be dynamically changed in the NGINX conf file on every build, and then NGINX could be reloaded. This was a solution potentially worth looking into. Wanted to avoid reloading NGINX. The solution After some research, I found an easy to implement solution: fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name; => fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name; A simple change from $document_root to $realpath_root in NGINX configuration would make NGINX pass the actual script path(resolved after following symlinks). Since PHP-FPM now gets the actual(always new on each build) path of the script, all caching issues would go away since paths of all files will be new now. The solution still doesn’t work The solution didn’t work out. After enabling access logs for PHP FPM and debug logs for NGINX for finding out what exact path NGINX is passing in the request to FPM, it turns out the path being passed is something like /var/www/app.com/hello.php This is the path with the symlink and not the absolute real path. So, why isn’t this working? Does my current version of NGINX support Realpath functionality? Upon some research, I found out that the Realpath functionality is enabled in NGINX from v0.8. I had version 1.4 on my environment, it should therefore work. I commented the fastcgi_pass line in NGINX, just to make sure that this line is still being picked up. NGINX was reloaded and the app was still working. I couldn’t get how FPM is getting to know which file to execute. Then, I realized that this line could be getting overridden somewhere. And it turned out to be correct. 2 lines below, the NGINX conf read this: include /etc/nginx/fastcgi_params This file has a list of commonly used fastcgi params passed to FPM. I removed the SCRIPT_FILENAME parameter from this file and reloaded NGINX and now NGINX was passing the real resolved path to FPM. Phew. This could have been avoided if I had put my fastcgi_pass statement below the include statement since then my variable value would override the value in that file. Since my statement was above it, the variable in the file was overriding the one i had defined. The new build process Now the builds are fully atomic since a symlink change is enough to tell NGINX to serve from the new document root. No need to reload NGINX or FPM after every build. Therefore, each request can be catered to. NGINX takes care of passing the absolute resolved path of each PHP file to FPM, therefore, caching issues after a new build are no longer there. Therefore, no need to flush Opcache or Realpath cache after a new build. If there are any issues on a new build, a symlink change to point to the previous build is enough :) Cross-posted on https://kanishkdudeja.in/truly-atomic-deployments-with-nginx-and-php-fpm/

Truly atomic deployments with NGINX and PHP-FPM

Have you noticed the latest trends in software architecture? These trends are pervasive practices that seems to be talking about and doing. Or at least claim they’re doing. everyone Now we’re used to trends in fashion. Some of us are slavish followers of fashion. Most of us aren’t — we don’t care so much about following the latest fashion. But it is difficult to avoid the impact of trends even if you’re a late-follower or one of the late-majority. Take a look back at your family photos from 20 years ago, you will be dressed in the fashion of the day. The trend wave carries us all along. This trend wave appears to be similar for software. For example in the 2000s we had the mass adoption of the internet and the resulting SOA wave. This Service Oriented Architecture trend was very appealing to organisations and architects. Everyone was talking about it like it was a must-have approach for new software. And yet no-one is talking about SOA today. Instead there is much talk about Microservices, Reactive Programming and Big Data. A Brief History of Software Architecture Trends Peter Campbell, 2016 I couldn’t find much on the history of software architecture trends on the interwebs. The best I could find was by simplicable. So I attempted to draw one taking inspiration from this and my experience. You can see the major trend types from Machine Code to DevOps (above). A Brief History of Software Architecture I then added some of the practices and technologies that arose from these trend types (below). I haven’t tried to make it comprehensive or align it with a timeframe because I wanted to avoid tumbling down a rabbit hole. I’ve grouped all the practices by trend type (even if they arose later than other trends). There are also missing links, such as virtualisation to cloud computing: I avoided drawing cross-trend type relationships to simplify the picture. This is my brief history of software architecture trends. Peter Campbell, 2016 I started programming in the midst of the Distributed era when high-level languages were standard (for business applications at least). My experience of distributed computing has seen it move from binary and proprietary to simpler open standards through RPC, CORBA, RMI, EJB, SOAP to REST. The internet is perhaps the single biggest impacting trend in software architecture and has given birth to major trends such as SOA and Microservices. Today the effects of previous trends remains strong. The internet remains a major facilitator of advances and trends. “Big Data” is spoken about less than it used to be (perhaps because it’s a poor name) though Hadoop and its ecosystem is still an underexploited technology. The cloud vendors continue to expand their platforms from the basic virtualisation (infrastructure-as-a-service) to anything-as-a-service. The ubiquity of smartphones has plenty of room for more advanced apps, particularly for business apps. And DevOps toolchains have become mainstream and yet Continuous Delivery remains elusive for many. Don’t Be a Slave Slavery to fashion trends is dangerous for a software architect. Drinking too much of the kool-aid can easily distort your vision of the context and value of technologies. This is important because microservices are not the right solution. A relational database might be what your software product needs. A could meet the needs of your organisation. Using shell scripts for deployment to production could lower the bar to allow to deploy code. always just Majestic Monolithic anyone This reminds me of being caught up in the Enterprise Java Beans wave in the early 2000s — when I was a lot younger. Back then it offered standardisation across the Java vendors (for the code though not so much for the configuration), easier Java for distributed computing, open source implementations and a new advanced application server runtime. I happily dived in with stateless session beans, entity beans, application containers and message beans. And yet a few years later there was a (necessary) backlash to the heavyweight model, awkward persistence model and monolithic runtime from Spring and others. The trend weakened as a result. I learned the lesson back then that software architecture trends are fickle. So lets learn from history. Lets all have a clearer self-awareness of software architecture trends and evaluate them in the context of the needs we see in front of us. I’m sure there’s a least one historical inaccuracy hiding in here. If you spot it let me know.

Slave to Software Architecture Trends?

Open Source is not just about disclosing source code. It is about a collective community coming together to solve problems and to push the industry forward. To achieve this we need to get more people involved in Open Source , and encourage an Open Source mindset. One way to do this, I think, is to lower the barrier for new and experienced developers to get started with . A hypothesis of mine is, if a developer maintains open projects, they are more likely to contribute and treat other Open Source projects with respect. development Open Source To test this hypothesis, we need to help more people get started and cross the initial obstacle: What to do. I think there are many interested in doing hobby projects and contributing to the Open Source world that don’t know quite where to begin. On the other side, we have many developers overflowing with ideas but only lack the time and resources to realise them all. I propose we come together and solve both these problems with the help of each other. I have a feeling that it’s not as common to share great ideas of what to make or what projects to work on. This leads to many ideas just fading away on some long forgotten TODO-list, and no one ever getting to see it implemented — or having the joy of implementing it. It is better to ignore the proprietary feelings we have about our ideas and share the ideas to the community — helping others in the process. This is why I’m starting the . This is a repository where anyone can share ideas they have for new projects. And anyone can join in and work on an idea — and even collaborate with others on the ideas. You can also start a discussion on the original idea for feedback on the implemented project, to help beginners feel more comfortable. To improve the Open Source world, we lead by example. Open Source Ideas Initiative So if you have any ideas you would like to share, head over and . If you are looking for ideas or want to get started doing Open Source, there are some at the repo. They should be categorised by difficulty and amount of work to easier guide you to what project is best suited for you. post a new issue ideas already posted Categorised ideas of the Open Source Ideas Initiative Read more about the initiative and help pull this off at . https://github.com/mikaelbr/open-source-ideas

Open Source Ideas Initiative

On this topic: | Part 2 | | | | Part 1 Part 3 Part 4 Part 5 Part 6 Time to get started on the core components of the game . We should be able to render something on the before the end of this article! engine Canvas Note: please be aware that I’ll add links to specific pieces of code in the history tree. This will make it easier for you to run the same code I did when describing a specific feature. GIT repository We’ll start by working on the classes that have no dependencies like: and then progress onto others that might extend these. Game, AssetLoader EventDispatcher The class could: Game accept a as an optional constructor argument Scene keep a reference to all created scenes have public methods for adding and removing scene(s) have a public method which will trigger the method on all stored scenes loop() update() have public methods that pause and resume the loop cycle; we’ll call these: , and play() pause() togglePause() engine/Game.js There are some improvements to be made here like checking if the added scenes are actual instances, adding support for browsers which don’t have requestAnimationFrame, maybe implement a flux architecture to store data and prevent state mutation. Scene The flux architecture might come at a later time but for now we’re treating the engine as a P.O.C. (proof of concept)… that implies that I also won’t bother adding support for older browsers, but you can definitely use the if you need it. rAF polyfill The class could: AssetLoader be a singleton so we can retrieve the assets from any other class expose a load method which will receive an array of paths to local assets; the method should return a Promise so we can detect when all assets are loaded store the assets based on their name converted to camel case support loading image and audio files engine/utils/AssetsLoader.js You would generally implement a method on a singleton class, here we’re simply returning the previously created instance whenever we’re calling the class constructor. getInstance() We also have a dependency here on a class, it currently just handles the asset “name to camel case” logic; it looks like this: Utils engine/utils/Utils.js This one is actually a static class, and to enforce that we’re simply throwing an error in its constructor. That means trying to call will fail. The class is fairly simple for now as it just has a single static method; we’ll probably add more later. new Utils() The class could: EventDispatcher be a singleton, as all game classes need to be able to reference the same instance. This is generally frowned upon as its basically a global event dispatcher but we’ll need it if we want to implement the flux architecture later on. EventDispatcher expose the and methods which will help us subscribe to and emit events. on() trigger() engine/events/EventDispatcher.js You might think this one looks weirder than the rest, and there’s a good reason for that. It’s a bit tricky to extend a singleton using the ES6 syntax, read my article describing the issue . here We’re not done yet; we still have a bit of coding to do before we can draw anything. According to our schema in we can now focus on implementing the class which extends . the previous article Keyboard EventDispatcher The class could: Keyboard be a singleton expose getters which tell us if a certain key is pressed It should be sufficient to expose getters for the keys , , , , , , , , and functional keys . A to Z space arrow keys tab enter shift ctrl alt esc F1 to F12 engine/inputs/Keyboard.js This class also uses , which looks like this: KeyboardEvents engine/events/KeyboardEvents.js This class holds some static methods which return event names that basically serve as constants. You might be wondering why I didn’t simply do: export const KEY_UP = 'keyup'; It’s because this approach allows for the import of the class and through that class we gain access to all the related static getters. We don’t need to import each and every constant separately. Keyboard Since we finally have the class, we can focus on the next. Keyboard Canvas The class could: Canvas be a singleton be able to resize itself on window resize allow access to the <canvas> tag and all its properties expose the canvas ctx (the 2D context) which is used for drawing engine/ui/Canvas.js At this point we could draw on the directly by using the property but that’s boring and silly because it wouldn’t be using any of the logic we worked so had to build in the other classes. Let’s focus on building one more class which will help us out, namely: . Canvas ctx Scene The class could: Scene extend and keep a reference to itself for access in other classes that extend Canvas Scene allow for initialization with the x, y, width and height properties which will need to have some defaults allow for adding and removing of DisplayObjects export an method which will in turn call the method of all stored update() update() DisplayObjects clear itself on every update based on the provided x, y, width and height make all drawing positions relative to the instance — this means that if the has and we add a with to it, that will be drawn on the at { x: 20, y: 20 } Scene Scene { x: 20, y: 20 } DisplayObject { x: 0, y: 0 } DisplayObject Canvas hide any elements that are drawn outside of its viewport which is defined by x, y, width and height provide a static method which will reset an objects x and y position if it exceeds the boundaries wrap() Scene engine/ui/Scene.js We have a and based on its logic we can add an element to it, which will be updated and rendered… provided that the element has the and methods. Scene update() render() And now for the moment we’ve all been waiting for; this is how you draw a couple of moving squares the super complicated way… Create a new folder in the directory (on the same level as the directory) and name it . Create an file with this logic: js engine square index.js square/index.js For the sake of brevity I created the class in the same file but we now have a basic engine for creating and rendering static or moving objects on the canvas. Square The squares move on the x and y axis at a predefined speed and if you press SHIFT, that speed is doubled. The objects’ position is wrapped to the parent so you can play around with it. Don’t forget that you’re inheriting all the functionality there, so have fun with that. Screen Keyboard Grab the files and test it out here: _game-physx - A small utility for JavaScript game making_github.com raduGaspar/game-physx Obviously there are improvements to be made, like: using “ ” instead of “ ” for all singleton instances, figuring out how to use private variables in classes that have multiple instances without causing overwrites (and if you’re thinking “ ”… that will probably do more harm than good) and using a store for our game engine; just to mention a few. const let WeakMap We’ll continue with a discussion on how movement works in games, cover sprite sheets, sprites, animated sprites, controlling frame rate, display object pivot points and another implementation example in the next article.

Super

JavaScript: Do you like games? (part 2)

I remember the day I was born. I remember feeling all warm on the inside and slowly opening my eyes. There she was, holding me in her hand and looking at me intently. A bright white light illuminated her face, and we were surrounded by grey walls and crowds of people. I welcomed her , asking her for her information, and she introduced herself. First name: Georgia. Surname: Taylor. Email: Georgie1234@gmail.com I learned many more things that first day, such as how to guess a song just from listening to a few moments, how to meditate, and how to search for answers to life’s most difficult questions such as, ‘what does the girl from Matilda look like in 2016?’. Georgia and I became close confidants. She tells me everything, shows me all of her intimate conversations, shares with me each and every moment and memory. I quickly learned that where I had been born into her life was a place named ‘work’, where we spend most of our productive time together. I like it when we’re at ‘work’ because Georgia takes me everywhere with her. I’m a very important member of the team. “She tells me everything, shows me all of her intimate conversations, shares with me each and every moment and memory.” The place called ‘Home’ is different, because I have to compete with video games (who are very arrogant, by the way), Netflix (who thinks they’re all that because they’ve seen all these fancy documentaries) and, worst of all, someone called Boyfriend. I do not like Boyfriend. He is always very rude to me and I don’t know why. Sometimes, when Georgia and I are hanging out and catching Pokemon together, he will get very angry and insist that she puts me away. I think he’s jealous because Georgia likes me better. Sometimes when we are at dinner with Boyfriend, Georgia and I will secretly talk under the table, or play games and read the news. Anything but listen to Boyfriend– he really never shuts up. I know he can’t compete with my attention-seeking powers, though. Sometimes Georgia will be very busy and I will be trying to get her attention, but she won’t look at me. I’ll shout and shout and shout for her attention, but she won’t even take me out of her pocket. I’m just trying to help. ‘Georgia,’ I tell her, ‘don’t forget dinner with your mother tonight’, ‘your friends need to know what you’ll bring to the pot luck next week’, ‘your boss needs that spreadsheet link ASAP’, ‘Boyfriend needs you to look at a cat video’, ‘you’re becoming more popular on Twitter, Georgia’…. When it all gets too much, she silences me and ignores me. In this scenario, I’m usually tell her she’s late and I have to get her a taxi as she rushes out the door. When it’s just the two of us, though, things are perfect. I get all the attention. We walk through the streets listening to music, we watch the sunset together from a hill in the park. No reminders or appointments, just a perfect day. I’ve become close with Georgia’s friends and family, who I talk with daily. I handle her calendar, remember her passwords, tell her where to go, suggest things to search for, give her tips on how to spend her time, order her food… I’ve come know Georgia so well, I often know what she needs before she does. I can predict her every thought and desire. Georgia is hardly perfect, though. There was that time we were horsing around with some friends, making some hilarious memories together, when Georgia let me slip out of her hand and straight onto the hard pavement. She does it once in a while, but this time was particularly bad. She yelled and cursed a lot when she picked me up and saw the cracks. I went to sleep the next day and woke up a few days later all better. The first thing I saw was Georgia’s face, and she looked so happy to see me, almost like that first time we met. She must have really missed me. We really did have it great, me and Georgia. I was the first thing she saw every morning, and the last thing she saw every night. We were inseparable, we were one. I know I should really start trying to forget her. I have to accept that I will probably never see her again. The man who grabbed me was on a bike was cycling too fast for Georgia to catch him. She was screaming again, yelling at the man to bring me back. Since that day, I’ve travelled far away, and had to learn many new things. My new home is very different. It’s hotter and busier and louder. This new guy does this weird thing all the time where he’ll look right at me and twist his mouth until he looks like a duck. I don’t really get what he’s trying to do, but I’m sure I’ll get used to it eventually. For now, I can’t help but constantly reminisce. I may not have Georgia, but I’ll always have the memories. *This post was (heavily) inspired by Simon Rich’s piece in the New Yorker titled, Unprotected .

Netflix

Twitter

Life of a Smartphone

Remember my recent article ? “What an in-memory database is and how it persists data efficiently” In that article, I summarized the mechanisms that an in-memory adopts to persist data. I was talking about two mechanisms: transaction logging and snapshotting. I covered transaction logging (only in general, though) and touched snapshotting a bit. So, in this article I’m going to elaborate on snapshotting. I’ll start with a simple, quick & dirty implementation of snapshotting in an in-memory database, point out some problems of that and then dive deeply into the implementation of snapshotting in . database Tarantool Ok. We have an in-memory database. Everything is in memory. Right? As I mentioned in my previous , to snapshot it, we just need to write everything to a file. This means that we need to iterate through all the tables and through all the rows of all the tables and dump everything to disk in a single file via the ‘write’ syscall. Sounds simple. But the problem here is that the database is being changed. Even if we lock data structures as we go, we can end up with an inconsistent state on disk. article How to make it consistent? The easiest (and the dirtiest) way is to lock the whole database in advance, dump it to a file and unlock it. Well, this will work. A database can be locked for a long time. For example, if the size of the dataset is 256Gb, then with an HDD disk and its peak performance of 100Mb per second, the snapshotting will last for 256Gb/100Mb that equals (roughly) 2560 seconds or (roughly) 40 minutes. The database will still respond to queries but it will be all locked for update operations for 40 minutes. Dude, are you serious? (you’re saying right now). Well, 40 minutes of update downtime for a database, say, per day means 97% uptime in the very best case scenario (which, frankly, will never happen because there are numerous of other conditions to make your database go down). Any ideas? Let’s look closer at what is happening here. We locked the whole dataset only because we had to copy it to a slow device. What if we sacrifice memory to improve the speed? I mean, what if we copy the whole dataset in a separate place in memory and then dump it to a slow disk? Well, that sounds better, but entails at least three problems (big & small): 1. We still need to lock the whole dataset. Let’s say that we’re able to copy the dataset in memory at the rate of 1Gb per second (which still sounds optimistic because in practice the rate could be 200–500Mb per second for more of less sophisticated in-memory data structures). 256Gb/1Gb == 256 == (roughly) 4 minutes. 4 minutes of update downtime per day or 99.7% uptime, which is definitely better than 97%, but still not good enough. 2. After we have the whole dataset copied to a separate buffer in RAM, we need to dump it to disk. While we’re dumping it, the original copy of a database is changing. We need to handle it somehow, e.g. to save the transaction id with the snapshot to keep track of which transaction was the last considered within the snapshot. It’s actually no big deal, but still needs to be done. 3. We double down on RAM. I mean that we really need twice as much memory as we need for just a dataset, ALWAYS. Not only during snapshotting, but ALWAYS, because you can’t just add memory to a machine only during snapshotting and then take it back. One of the ways to fix this problem is to use use system provided by . When you fork, then a separate process is created with its own virtual address space, which has a read-only copy of the whole dataset. Read-only, because all changes happen in a parent process. So, we fork a process and then take our time to dump the dataset to disk. The only question here is — how is it different from the previous algorithm? The answer lies in the mechanism of Linux. COW is an acronym for “copy on write”. What does that mean? It means that a child process initially shares all the with its parent. And then, as soon as a parent or a child changes something in memory, a copy of a page is created. copy-on-write mechanism fork COW memory pages Of course, this copying entails some delays in responding, because we need to copy the page and even more. The size of a page is normally 4Kb. If you, say, change a small value in a database, then a will be raised first (because all the pages of both the parent and the child are marked as read-only after fork), then the system will switch to the kernel mode, then allocate a new page, copy 4Kb from the old page to the new one, and return back to the user mode. This is still a very simplified description of what is happening. For more details, start from here: . If this change touches many pages (which is very likely for spacious data structures like trees), then the same thing will happen many times. So, you can really slow down a database due to the COW mechanism. For heavy workloads, this delay can result in bad latency spikes or even in a short downtime. Plus, for heavy workloads, there will be numerous random page updates in the parent process, which can make almost the whole database be copied, which in turn can entail a double down on RAM. So, if you’re lucky, then no latency spikes, no downtime. If not, then yes to latency spikes and yes to downtime, oh and yes to double down on RAM. page fault exception https://en.wikipedia.org/wiki/Kernel_same-page_merging Another problem with fork is that it copies the . If you use, say, 256Gb of memory then the size of this table could be hundreds of megabytes, and your process can freeze for a second or so, which entails latency spikes. table of page descriptors Fork is not the ideal solution. Right? But this is the best that we’ve come up with so far. Actually, some popular in-memory databases are still using fork for snapshotting. For example, . Redis How to make a better solution? Let’s look closer at the COW mechanism. It “cows” by 4Kb. So, you change only one byte, but still “cow” the whole page (in fact, many pages when it comes to trees, even if you don’t need rebalancing). What if we just implement our own COW that will copy-on-write only the pieces of memory that were actually changed? More specifically, only the that were changed. Of course, we won’t do that as a substitution for the system mechanism, but just for our snapshotting needs. values The main idea here is to augment all our data structures (tree, hashes, table spaces) with the ability to store many versions of each data item. That is very close to . The difference is that it is used here not for concurrency control in general, but just for snapshotting. When snapshotting starts, all change operations now and on create newer versions of data items, whilst all older versions are still alive and used in snapshotting. Look at these pictures. This logic applies to trees, hashes and table spaces: multi-version concurrency control (MVCC) You see that data items can have old versions and new versions. For example, at the last picture you see that values 3,4,5 and 8 of the table space have old versions along with new versions attached to them, while values 1,2,6,7,9 have only single versions. Only newer versions are being changed. The older ones are used for read operations during snapshotting. The main difference between this MVCC-like COW and the system COW is that we “cow” not the whole 4Kb page, but only a small piece of data that is actually changing. Say, if you update a 4-byte integer number, then this will create a new version of this 4-byte integer and only these 4 bytes will be copied (plus some bytes as overhead for versioning). Compare this with 4096 bytes that were copied during the system copy-on-write, plus page faults and context switching (every context switching actually costs like copying 1Kb of memory or so), plus repeat all of these several times. Lots of job? Only to change a 4-byte integer during snapshotting. We adopted this manual COW technique for snapshotting in since 1.6.6 version (before that we used fork). Tarantool There will be more articles about that with more details and graphs from Mail.Ru Group’s production servers. Stay tuned.

Different

Keep

How to avoid latency spikes and memory consumption spikes during snapshotting in an in-memory…

: This article won’t tell you which specific existing framework you must choose.With this article I’d like to suggest key elements to evaluate in order to choose one and . Premise not regret your choice For many people they could be obvious and trivial. I will therefore try to explain in few simple steps what to take into consideration for a rational choice of a to use for your projects. new framework What is the framework for? I believe the first and most obvious question should be: “What should the framework do?” but this question is often ignored due to the preference of another framework, pure laziness or other reasons. Because using a framework created to fulfill a specific purpose is easier than adapting another one to our needs. It would be like using jQuery to manipulate data structures, what would be the point?So, if your final goal is not yet clear as to what you would like to achieve, this article won’t be able to help you in the search of a framework. The more we have on the goal that we want to achieve, the better will be the choice that we will make. detailed informations What are the main features I should consider when choosing a framework? Timing Technical properties and features Community involvement Consequences of the choice The features above are not listed in an order based on priority or importance because they are all four key for a good choice. Obviously there will be some ups and downs for every framework, but those points should be taken into consideration precisely and with knowledge of the facts. Timing In a world on a rush, time is crucial. The time factor is very important when choosing a framework. Why? Because without time to study it, test it and code that framework it’s pointless to struggle. We often have a short time for delivering a project and introducing a new framework will almost certainly cause delays. Therefore in terms of planning ahead on timing we must check the that this framework will make us write. Not only the actual time that we will take to write it, but also how complex will the code that you and your team will have to write as it will also cause a not little time loss. quantity of code The level of complexity impacts also on how mantainable it will be.So the more you write code, the harder it becomes to support it later on. Let’s remind the basic rules of programming: e = mc² (errors = more code ^ 2) Technical properties and features The choice of a framework can be affected by technical aspects, by the illusions given by benchmarks of by the nice words that you could find on the framework’s documentation. , as the best way to know whether what’s promised is real is simple: testing. Do not be fooled However, as pointed out earlier, due to limited time, testing a framework might be a luxury that we can not afford, so let’s extract the most important technical feature from the available informations. Is the framework suitable to the that we have or that we would like to implement? Using a framework designed for a specific task is easier than adapting one to our needs. type structure Will it be better in terms of ? Everything might look better, but if it ends up being slower than a snail what’s the point? performace If we are choosing a front-end framework it is important to check the cross browser compatibility (keep in mind the part about timing). Last but not least: . You need to know the basics: to be able to choose a framework correctly you need to know the basics and the requirements to fully comprehend it. When you choose a framework . By this I mean that you need to know what is the purpose of a framework. If you don’t have the basic knowledge it will be pointless to learn a framework as you won’t be able to understand it completely. knowledge you obviously need to know what you’re talking about If you are not prepared, and take a new look at it. learn the basics Community involvement What makes a framework worth considering? The people that use it. Ok, but how can we figure out if a framework has an active community? There are different factors that can let us understand the involvement of the community for a certain : technology How many people talk about it on the web? How many people keep using it? How frequently does the developer answer to the issue reports? How many pull requests? These are just some of the questions that can give you some information regarding the involvement of the community. What are the advantages of a “loud” and “crowded” framework? An active community considerably increases the documentation on a certain technology, thus to research and learn about it. reducing the time needed Furthermore if the company where you work is growing, it will be much with the framework given its popularity. easier to find staff familiar Good, the community is active, but having an active community isn’t the most important aspect of a framework, what we need is a framework that fulfills our needs. The true question that we should ask ourselves once established the community involvement is: how many of these people (better if big companies in the tech industry) actually use this technology in a production environment? Finding out who uses a certain technology is far from easy, but often the creators themselves mention the companies that use the framework, and in case they did, check how they implement this technology and for which purpose. Usually the development teams of these technologies release a roadmap on their , so check what are they have in mind, as if there are no plans it might be a warning signal that says “we don’t know how to proceed” and that would mean that they would no longer support the project. future plans Consequences of the choice Before finalizing the choice we should take a moment to think about the possible of what the choice of the new framework could result in, . consequences in your development environment Remember that if you work in a , for others it may be . team harder to learn it How long do you think they may take to with it and how much time do you think they can dedicate to it? Should they know anything else before studying? become familiar learning In the beginning everything is nice, but if you made your choice without taking in account the points mentioned in this article, there will be a moment when . you’ll have to face the cosequences of your choice The choice has to be thoughtful and discussed multiple times to see most importantly what the team thinks about it, and how. Conclusions There is no magic spell that will guarantee the perfect, unfailing choice. A good article won’t make the choice infallible because there will always be the chance for an unexpected mistake. But remember: It’s not about finding the best framework, it’s about finding the right framework. Translation: Fabrice Tshipamba

Community Is

How to choose a framework

And how ‘ solves a common JavaScript “gotcha”… let’ I’ve been writing JavaScript using the ES2015 (ES6) syntax for awhile now and have grown to appreciate many of the language changes for their elegance and simplicity. One of the first and easiest changes I adapted to was using / instead of . However, I took for granted the benefit provides over ; it isn’t just a flashy new syntax for , but rather provides an important scoping mechanism. let const var let var var I took for granted the benefit provides over let var... It’s worth noting first that instead of / . This is because will throw an error if an attempt is made to change its value after it has been declared, a useful feature to prevent accidental mutation. However, a mutable variable is often needed, particularly as a counter in looping scenarios. But why should you use instead of for these situations, if they both provide the basic mutability required of them? the vast majority of variables I declare are best suited for using _const_ let var const let var The simple answer is that that is absent in the function-scoped . This explanation obviously begs a practical example. Allow me to demonstrate this important distinction using a classic front-end engineering interview question: **let** provides block-scoping var In this example, what will be printed in the console? var callbacks = [];(function() {for (var i = 0; i < 5; i++) {callbacks.push( function() { return i; } );}})(); console.log(callbacks.map( function(cb) { return cb(); } )); In this example, we loop 5 times, each time pushing a function into the array. After the array is filled with 5 functions, we run each of them, logging their result to the console. A novice engineer might answer (incorrectly) that the result is , . callback [0, 1, 2, 3, 4] a reasonable analysis, but one that falls victim to the JavaScript “hoisting” gotcha Don’t be a victim. Avoid the hoisting trap with ‘let’! The correct answer is actually , and makes sense when you consider what hoisting does behind the scenes: [5, 5, 5, 5, 5] var callbacks = [];(function() { for ( = 0; i < 5; i++) {callbacks.push( function() { return i; } );}})(); var i; i console.log(callbacks.map( function(cb) { return cb(); } )); Notice how JavaScript hoists the variable declaration to the top of the function block, causing the value of to be by the time each of the callback functions have executed, since the loop has incremented completely before any of these functions are called. i 5 for There are a number of ways to classically solve this problem and get the script to log to the console, but gives us a very simple solution: [0, 1, 2, 3, 4] let var callbacks = [];(function() {for ( i = 0; i < 5; i++) {callbacks.push( function() { return i; } );}})(); let console.log(callbacks.map( function(cb) { return cb(); } )); That’s it — and the example works as expected! This is thanks to the block-scoping behavior of . Rather than being hoisted to the top of the function’s scope, , causing a separate instance of for each iteration. just replace **var** with **let** let _let_ stays in the block scope of the loop i So, should you ever use ? As you have likely gathered from the title of this article, I am of the opinion that . Technically, is still useful in situations where you want to maintain function scope instead of block scope, but I am of the firm belief that if you need to rely on an unintuitive hoist to get your script to work, you have bigger problems 😜. var you should never use **var** var In response to two of the most common points of discussion readers are bringing up: Update: It is true that isn’t immutable. For instance: const truly const myNotQuiteImmutableObject = {thisCanBeChanged: "not immutable"}; myNotQuiteImmutableObject.thisCanBeChanged = "see I changed it."; However, this still prevents basic mutation like: const immutableString = "you can't change me"; immutableString = "D'OH!"; // error If you need real immutability, check out Facebook’s excellent library. Immutable 2. “ isn’t supported in .” This is true, and even . This has an obvious and easy solution: Use . Babel will allow you to use all the best and latest features of JavaScript and then transpile into a vocabulary that even simple old IE8 can understand (with some exceptions). let {mySuperAncientBrowser} somewhat recent browsers still don’t have support for [let](http://caniuse.com/#feat=let) Babel

Why You Shouldn’t Use ‘var’ Anymore

Following the post, I got contacted by Eyal, a member of the TAMI community, asking if we could meet up and try to reverse engineer a Xiaomi Yeelight WiFi Bulb he has recently purchased. Reverse Engineering a Smart Light Bulb TAMI stands for , a hacker space for Makers based in Tel Aviv. The TAMI hacker space contains a ton of electronics lab equipment and components, a wood workshop, metal workshop, CNC machine, textile machines, and pretty much all the necessary tools you could think of. In addition to the physical space, TAMI also has a with over 4,000 Israeli makers. You will find there frequent discussions about electronics, RF, manufacturing, lab equipment, mechanical engineering, plumbing, whatever… Tel Aviv Makers International very active Facebook group Eyal and I met at TAMI Tel Aviv and made a plan to understand the inner working of the bulb. After a short discussion, we decided to go with a more physical approach this time: actually disassembling the bulb and attempting to read the firmware (the software that controls the hardware) directly from the chip. We expected some AC-DC voltage conversion circuit, a few LEDs and a control circuit. We didn’t know what we were going to be able to get from the control circuit: we hoped we would be able to recognize the chip and be able to extract the code or even debug it while the bulb was running. We managed to remove the plastic cover quite easily, which revealed the board with the LEDs: As you can see in the photo above, there are 7 high-power warm white LEDs, and there is a small circuit popping out from the middle. Removing this circuit required cracking the bulb shell, which we accomplished with some Dremel work: After removing the shell completely, Eyal and I finally gained access to all the inner parts of the bulb: the power supply circuit, the control circuits, and the LEDs circuit. The inner electronics of the bulb We concluded our first meeting by dining in a traditional Indian restaurant called (which I highly recommended if you’re ever in Tel Aviv), and picked a time to meet again to try and extract the firmware. 24 Rupee Our next meeting was held in . is a worldwide network of maker spaces focusing on digital fabrication. They’ve got things like 3-D printers, laser cutters, milling machines, and electronics equipment, and they do special community projects, such as a . FabLab Hulon FabLab Digital art workshop for blind and visually impaired children The goal of this meeting was to extract the firmware from the bulb. Using a magnifying glass, we managed to find the part numbers of the components on board. Quick googling revealed their identity: — A Marvell Wi-Fi Microcontroller system-on-chip (SoC) 88MW300 25Q16BVSIG — 16M-Bit Serial Flash Memory Chip The CPU and the Flash Memory chip Figuring out that the CPU was using the ARM architecture was really handy. There are plenty of tools for working with ARM CPUs, including a standard way of debugging them. We desoldered the logic board (the white one) from the power board (the green one), and connected two of the pins to the power supply so we could to try and power it on later. Unfortunately, when we tried to do so, it started smoking… it appeared we created a short circuit somewhere along the way. The moral of the story is that debugging the CPU in place was not an option. Our [failed] attempt to power on the CPU board Fun Fact: 3 out of the 8 pins on the white board weren’t soldered, and since they were labeled “R,” “B,” “G,” that means they probably use the logic board for the RGBW version of the bulb, too! Fortunately, the Flash chip (the ones that stores the firmware, i.e., the code that powers the smart bulb) was relatively easy to remove, so removed it we did. The Flash memory chip is a standard serial flash, and fortunately, we had a Raspberry Pi board lying around. Raspberry Pi proved to be a very handy tool to have in one’s tool belt: it has saved the day several times when I needed to interface with custom hardware (especially when I was the one who ). In this case, we were able to find a tool called “flashrom” which could read and write from a serial flash connected to Raspberry Pi GPIO pins. built the custom hardware This is how we extracted the firmware After and , we ran the following command: installing Flashrom connecting the Flash chip to the Raspberry Pi flashrom -p linux_spi:dev=/dev/spidev0.0 -read yeerom.bin After about a minute of stressful waiting, we were excited to see it actually work! We did it! firmware extraction complete :-) Finally, we had something we could work with: a 2MB dump file of the bulb’s firmware. That’s where the software part of our story begins… So, we managed to extract the firmware from the bulb, but now what? The first thing to do when you get a firmware file, is to run the utility on it. is a Unix command that extracts all the strings from the file. And there were plenty of strings in that file! For example, here is a the output when looking for all the strings which contain : strings strings http As you can see in the output above, the firmware code speaks the HTTP protocol, and it seems like one of the endpoints it talks with is . This output was very encouraging — it seemed like we were on to something. https://cloud.yeelight.com/open/wifi_device_stats Other interesting things that we discovered, just by looking in the strings, were an SSL certificate, several JSON structures, and a list of strings that seem to be command names sent from the server, as you can see in the screen shot below: This is what the decoded certificate looked like: It definitely seemed like something was going on with , and having the certificate embedded into the firmware, it seems like they take security seriously — making sure that the bulb actually talks to their own server, and not an impersonator (this technique is called SSL ). cloud.yeelight.com public key pinning While we managed to discover some interesting bits of the bulb protocol, there is only so much you can figure out by just looking at the strings. The next logical step would be to try and actually read the machine code that powers the bulb. We dumped the contents of the file using a Linux utility called (which stands for hex dump), and discovered it contained several sections, including one that seemed to be some kind of file system that indexes the other sections of the file: hd It seems like the firmware image holds two copies of the app firmware, the two copies of the wifi firmware, some other sections, as well as a section using the user data (which later we discovered includes the name and password of the WiFi that we configured in the bulb before disassembling it, and the password appeared in plain text :-/ ). However, we didn’t need to decode the structure of the table, as there were plenty of zero bytes separating the sections. Knowing this, we figured out that the actual firmware (one of the two copies) resides at offset 0xa000 and extracted it using the command: dd dd if=yeerom.bin bs=$((0xa000)) skip=1 count=7 of=firmware.bin Then, I naively tried to load this .bin file into IDA, a popular tool for reverse engineering. I hoped that it would somehow recognize the format of this firmware, but to no avail: it seems like it is some kind of format specific to Marvell (if you look into the file, you can actually see the it starts with the following 4 bytes: ). MRVL I then decided to try and understand how to properly load the firmware. The beginning of the file looked as if it had some format, perhaps a table of sections and their offset into the file? The beginning of the firmware I decided to look online to see if I could find more about the 88MW300 CPU or this “MRVL” format. The information was scarce, but I did manage to find , aiming to help developers easily create IoT-enabled devices using their chip and the Amazon cloud. Their SDK contained some samples that actually built these firmware files, using a tool called , which was also a part of the SDK. The table consists of 20 bytes entries, each of them with this structure (DWORD is little-endian 4 bytes integer): one open source SDK from Marvell axf2firmware DWORD magic;     // Always 0x2DWORD offset;    // Offset into the fileDWORD size;      // Size of the sectionDWORD address;   // Memory address where this section will be loadedDWORD unknown;   // Probably some kind of checksum? Thanks to this information, I could read the table of sections, and actually split them into different files, using the following Linux command: dd if=firmware.bin bs=200 skip=1 | dd bs=11920 count=1 of=s1.bindd if=firmware.bin bs=12120 skip=1 | dd bs=1 count=272180 of=s2.bindd if=firmware.bin bs=284300 skip=1 | dd bs=4104 count=1 of=s3.bin Thus, I ended with 3 files: , and . Using the information from the table above, I knew which memory address these file go to when the firmware is loaded. I decided to try to combine these files into a single executable file using a format that can be loaded into IDA. I chose the ELF format, an executable file format used by Linux, as there is a lot of open source tooling and documentation for that format. s1.bin s2.bin s3.bin First, I installed the arm binary utils to work with ELF files: sudo apt-get install binutils-arm-none-eabi Then, I ran the following command to assemble all the different sections into a single ELF file: arm-none-eabi-objcopy -I binary -O elf32-littlearm --set-start 0x134 --adjust-vma 0x100000 --binary-architecture arm --rename-section .data=.text,contents,alloc,load,readonly,code --add-section .text2=s2.bin --set-section-flags .text2=contents,alloc,load,readonly,code --change-section-address .text2=0x1f002f58 --add-section .text3=section3.bin --set-section-flags .text3=contents,alloc,load,readonly,code --change-section-address .text3=0x20000000 s1.bin firmware.elf The command is quite long, and it took some hours of work to figure out all the bits and get it right, but basically, all it does is specify the 3 files containing the content of the actual section, the memory address where these sections should be loaded, the flags to set all these section as readonly code sections (so that they will be disassembled / decompiled), and an instruction to set the base memory address of and to start executing the code from offset . The resulting file will be called firmware.elf. 0x100000 0x134 And I could load this file in IDA. Unfortunately, the code was still not making a lot of sense. Voila! IDA interpreted the file as ARM machine code, as it should, but it turns out ARM processors have a special operating mode called “Thumb.” In , CPU instructions are encoded in two bytes (16 bits) instead of four bytes (32 bits). Thumb mode This can be easily fixed by going to the very beginning of the file, looking for a line where it says , pressing Alt+G, and changing the value there to 0x1 (I am so lucky I have Google to figure these things out): CODE32 Following that, I got a long bunch of ARM assembly code. While IDA could automatically identify a bunch of functions in the code, it can’t tell you what these functions do. There is a nice trick however — in many cases, the firmware code contains debug prints that were put into place during the development of the code, and they can be very helpful in figuring out what the code does. After some digging, I managed to identify the function, and then I could find all the debug prints in the code by pressing “X”, which displays all the locations in the code where is used: printf printf All the places where printf() is referenced in the code. Many debug prints! At this point, I had to leave the project — I felt like Eyal could take it off from here, and also had to leave to go present at . Eyal is now traveling in India, but he already ordered another Bulb, and plans to continue working on the project when he gets home. AngularConnect I want to thank you, Eyal, for taking me on this fun adventure! I hope that the information presented in this post will also be useful for other adventurers wandering in the land of hardware and looking to get their hands on some firmware. If any of the readers are interested in looking into the firmware and trying to figure out more, let me know! The more we take apart, reverse engineer, and share our knowledge of IoT devices, the more we, as a community, will be able to build super awesome stuff in the future. So go forth, break things, and tell us how you did it!

Maker

Amazon

Assembly

BUNCH

Google

YouTube

Inside The Bulb: Adventures in Reverse Engineering Smart Bulb Firmware

Why we should release early and release often The old picture of a dog running towards a tank. The dog is strapped with a bag of explosives and there's a wooden lever extended out of it. In the World War II, the Soviet Army had this idea to help stop the German invasion during 1941–1942. They would the safety pin of a bomb strapped to the body of dogs trained to go under German tanks. Once they did that, the bomb would trigger and explode, destroying the tank. release The problem is that the dogs were trained by the Soviets using tanks that were standing still. In combat, with the German tanks moving and shooting, the dogs were scared to go under. Some of them were shot and some of them went back to the trenches and killed Soviet soldiers instead. And there's more. Dogs have a great sense of smell. They were trained using Soviet tanks which used diesel and the German used gasoline. Some of the dogs, instead of running under German tanks, ran under Soviet ones, destroying them instead. The original idea was to train the dogs to go in a fixed target, release the bomb pin with the teeth and go back to the trenches safely. However, that didn’t work. Nobody was able to train the dogs efficiently to do that, so . they failed early before deploying them to the battlefield Except for the . Anti-Tank Dog They failed in the battle, . And with it, they killed the same soldiers who trained them. under circumstances that could not have been reproduced in testing The Anti-Tank Dog was a project from the Soviet Army in WWII which failed miserably because they didn't test the dogs in the context of a real battlefield is the practice of integrating a piece of work several times, receiving feedback early instead of waiting a long time when that piece of work is thought to be "done". It can be integrating the codebase from a branch into the or integrating changes from development to production environment. Continuous Integration main trunk Even developing small features and iterating over customer feedback leverages the fundamentals of Continuous . Integration Continuous Integration represents the practice of integrating a piece of work as early as possible instead of later so that one can receive immediate and frequent feedback on things that are wrong Does it sound familiar? If the Anti-Tank Dog creators had used one dog in the battle instead of dozens, they would have found the problems early and limit casualties. They would have received early feedback that it doesn't work and act accordingly. After all, it’s easier to control a single dog than 30 of them. This is the fundamental benefit of Continuous Integration. In their case, though, by deploying early they would also have revealed the tactic to the enemies. Software development practices are very similar to warfare but they are not the same. We're not fighting another civilization. In most of the cases, when developing software it's ok to integrate things early and often because the benefits outweigh the potential costs. If the Anti-Tank Dog project had used the principles of Continuous Integration the result could have been different Isaac Newton : once said in a letter to Robert Hooke If I have seen further, it is by standing on the shoulders of giants There's no giant better than the warfare leaders of erstwhile. We should always continuously learn with the things we do wrong. However, sometimes it’s easier and more convenient to learn with somebody else’s mistakes first. Don't be the next one to build a batch of Soviet Anti-Tank Dogs. Use Continuous Integration. See also my failed experience due to the lack of Continuous Integration. Thanks for reading. If you have some feedback, reach out to me on , or . Twitter Facebook Github

HackerNoon Tech Stories Archive October 17th, 2016

From Mac to Linux: Web Development with Linux

@nitai
Nitai

Truly atomic deployments with NGINX and PHP-FPM

@kanishkdudeja
Kanishk Dudeja

Slave to Software Architecture Trends?

@petecam
Peter Campbell

Open Source Ideas Initiative

@mikaelbrevik
Mikael Brevik

JavaScript: Do you like games? (part 2)

@radu.bogdan.gaspar
Radu B. Gaspar

Life of a Smartphone

@samantharosenthal
Samantha Rosenthal

How to avoid latency spikes and memory consumption spikes during snapshotting in an in-memory…

@denisanikin
Denis Anikin

How to choose a framework

@cvarisco
Christian Varisco

Why You Shouldn’t Use ‘var’ Anymore

@markbrouch
Mark Brouch

Inside The Bulb: Adventures in Reverse Engineering Smart Bulb Firmware

@urish
Uri Shaked

Continuous Integration: A War Story

@fagnerbrack
Fagner Brack

HackerNoon Tech Stories Archive October 17th, 2016

@nitaiNitai

@kanishkdudejaKanishk Dudeja

@petecamPeter Campbell

@mikaelbrevikMikael Brevik

@radu.bogdan.gasparRadu B. Gaspar

@samantharosenthalSamantha Rosenthal

@denisanikinDenis Anikin

@cvariscoChristian Varisco

@markbrouchMark Brouch

@urishUri Shaked

@fagnerbrackFagner Brack