GitHub - jwasham/coding-interview-university: A complete computer science study plan to become a software engineer.

GitHub - jwasham/coding-interview-university: A complete computer science study plan to become a software engineer.: "This is my multi-month study plan for going from web developer (self-taught, no CS degree) to software engineer for a large company.



This is meant for new software engineers or those switching from software/web development to software engineering (where computer science knowledge is required). If you have many years of experience and are claiming many years of software engineering experience, expect a harder interview.

If you have many years of software/web development experience, note that large software companies like Google, Amazon, Facebook and Microsoft view software engineering as different from software/web development, and they require computer science knowledge.

If you want to be a reliability engineer or operations engineer, study more from the optional list (networking, security)."



'via Blog this'

Serverless and Deployment Issues – Paul Johnston – Medium

Serverless and Deployment Issues – Paul Johnston – Medium:

Currently, deployment tools give us monolithic deployment scenarios for Serverless.

This is unfortunate, but a direct consequence of utilising tools that aren’t built for a Serverless deployment.

We’re in a bit of a waiting phase before someone develops much more granular deployment tools.

Until
we have tools and infrastructure providers that allow us to do things
like blue/green and canarying on functions in a relatively simple way,
then we’re going to have to roll our own tools to deliver this. It’s not
easy, but it’s what we’ve been doing for the last couple of years
anyway.

'via Blog this'

How I got to 200 productive hours a month

How I got to 200 productive hours a month: "When improving your productivity, don't expect it to increase in a week because the brain needs a lot of time to restructure to new behaviors. Instead, set a small performance goal like "get 5% better each month." Aiming for faster results will make you too stressed out, while productivity requires a calm mind and a well-rested body. Be tough on your ineffective habits, but please be easy on yourself."



'via Blog this'

LinkedIn's Tips for Highly Effective Code Review - The New Stack

LinkedIn's Tips for Highly Effective Code Review - The New Stack: "In summary, having a formal code review process helps improve code quality, team learning, and knowledge sharing. The quality of work increases when every engineer on the team realizes two important things: someone else will read my code, so it better be good, and I’ll have to address any review comments I receive, so I should try to make my code good the first time around to save myself effort later on. When code reviews become an everyday habit, the team practices giving and receiving feedback on a daily basis. This is key for growth and improvement."



'via Blog this'

GitHub - twitter/reasonable-scala: An experimental Scala compiler focused on compilation speed

GitHub - twitter/reasonable-scala: An experimental Scala compiler focused on compilation speed: "Reasonable Scala compiler (rsc) is an experimental Scala compiler focused on compilation speed. This project is developed by Eugene Burmako and his team at Twitter.



 At Twitter, we have one of the biggest Scala codebases on the planet, and compilation time is consistently among the top asks from our engineers. With rsc, we seek to foster innovation in compilation performance, openly prototyping performance-focused designs and making our findings available to the Scala community at large."



'via Blog this'

Security: Exploits of a mom

Managing Data in Microservices

Managing Data in Microservices:



Randy Shoup shares proven patterns that have been successful at Google, eBay, and Stitch Fix. Shoup covers managing data, the need to isolate a microservice's data store behind the service interface, using events as a first-class tool in the architectural toolbox, techniques for service extraction from a monolithic database and much more.



'via Blog this'

A Look into NASA’s Coding Philosophy – Student Voices

A Look into NASA’s Coding Philosophy – Student Voices: "With some years of work there, I wish to provide a first-hand account on the philosophy that’s allowed the space agency to produce some of the world’s most reliable software, and I’ll frame their attitude towards programming with a set of four assumptions I think they make for programmers in the workforce (and which I have experienced directly."



'via Blog this'

100 days of algorithms challenge – 100 days of algorithms – Medium

100 days of algorithms challenge – 100 days of algorithms – Medium: "Two of my colleagues, Jirka Penzéš and Jarda Holáň, brought me to this idea. And I love it. For the next period of my life I’m going to publish an implementation of algorithm regularly, day by day, until the number reaches 100."



'via Blog this'

AWS/Java: Why the JVM is a Good Choice for Serverless Computing: John Chapin Discusses AWS Lambda at QCon NY

Why the JVM is a Good Choice for Serverless Computing: John Chapin Discusses AWS Lambda at QCon NY: "Chapin summarised the talk by stating that he recommends using Lambda's JVM runtime to build business applications, and developers should focus on reducing and amortising cold start impact, benchmark functions extensively, and use real logging and metrics. Additional information on John Chapin's presentation, "Fearless AWS Lambdas", can be found on the QCon New York website, and the video recording will be made available on InfoQ in the coming months."



'via Blog this'

AWS: You probably shouldn’t use DynamoDB – Ravelin Tech

AWS: You probably shouldn’t use DynamoDB – Ravelin Tech: "There are many use cases where DynamoDB is likely a good solution. If you know your dataset size is relatively small or your query distribution is high enough that the above scenario doesn’t apply to you then DynamoDB could help you solve problems. I have seen it used as a method for deduping where data is not stored long term so the dataset size does not grow. It is a fast and highly available tool if you can get around the issue I mentioned above. This article is pretty damning of DynamoDB but it really should be read as an indictment of our particular expectations of the database. If you set your expectations differently and work within the restrictions you might find a good use for the product."



'via Blog this'

Nuts and Bolts of Multithreaded Programming | Intel® Software

Nuts and Bolts of Multithreaded Programming | Intel® Software: "Get the basics about parallel algorithms, parallel programming APIs, and the tools required to start writing your own parallel programs."



'via Blog this'

Amazon’s New Customer – Stratechery by Ben Thompson

Amazon’s New Customer – Stratechery by Ben Thompson: "I suspect Amazon’s ambitions stretch further, though: Amazon Grocery Services will be well-placed to start supplying restaurants too, gaining Amazon access to another big cut of economic activity. It is the AWS model, which is to say it is the Amazon model, but like AWS, the key to profitability is having a first-and-best customer able to utilize the massive investment necessary to build the service out in the first place."



'via Blog this'

C/C++: Beginner's Guide to Linkers

Beginner's Guide to Linkers: "This article is intended to help C & C++ programmers understand the essentials of what the linker does. I've explained this to a number of colleagues over the years, so I decided it was time to write it down so that it's more widely available (and so that I don't have to explain it again)"



'via Blog this'

web: API Best Practices: Hypermedia (Part 4.1) | MuleSoft Blog

API Best Practices: Hypermedia (Part 4.1) | MuleSoft Blog: "Hypermedia is often misunderstood in regards to APIs, but essentially it functions exactly like links on a webpage. And while the technology is both praised and criticized, it does provide an array of short and long-term gains. These gains, I believe, become more and more noticeable the larger and more complex your API becomes. However, the best features of utilizing HATEOAS, in my opinion, are yet to be seen as technology and API exploration tools continue to advance."



'via Blog this'

System programming in Rust: beyond safety | the morning paper

System programming in Rust: beyond safety | the morning paper: "About 2/3 of the 2017 CVEs relating to the Linux kernel can be attributed to the use of an unsafe language, and pervasive use of pointer aliasing, pointer arithmetic and unsafe type casts defeat the use of software verification tools.

So why are we still using C? Because safe languages have overheads that are too high for many use cases argue the authors. (And because of familiarity, and large existing C codebases, I would add)."



'via Blog this'

You Are Not Google – Bradfield

You Are Not Google – Bradfield:

"Cool Tech? UNPHAT.

Next time you find yourself Googling some cool new technology to (re)build your architecture around, I urge you to stop and follow UNPHAT instead:
Don’t even start considering solutions until you



Understand the problem. Your goal should be to “solve” the problem mostly within the problem domain, not the solution domain.

eNumerate multiple candidate solutions. Don’t just start prodding at your favorite!

Consider a candidate solution, then read the Paper if there is one.

Determine the Historical context in which the candidate solution was designed or developed.

Weigh Advantages against disadvantages.

Determine what was de-prioritized to achieve what was prioritized.

 Think! Soberly and humbly ponder how well this solution fits your problem. What fact would need to be different for you to change your mind? For instance, how much smaller would the data need to be before you’d elect not to use Hadoop?"



'via Blog this'

Ask HN: What language-agnostic programming books should I read? | Hacker News

Ask HN: What language-agnostic programming books should I read? | Hacker News: " What language-agnostic programming books should I read?"



'via Blog this'

Python version of "Structure and Interpretation of Computer Programs "

CS61A, Spring 2012 Online Textbook: "This book is derived from the classic textbook Structure and Interpretation of Computer Programs by Abelson, Sussman, and Sussman. John Denero originally modified if for Python for the Fall 2011 semester. It is licensed under the Creative Commons Attribution-ShareAlike 3.0 license."



'via Blog this'

Networking Protocols – Programmer's Compendium Programmer's Compendium

Network Protocols – Programmer's Compendium Programmer's Compendium:



The network stack does several seemingly-impossible things. It does reliable transmission over our unreliable networks, usually without any detectable hiccups. It adapts smoothly to network congestion. It provides addressing to billions of active nodes. It routes packets around damaged network infrastructure, reassembling them in the correct order on the other side even if they arrived out of order. It accommodates esoteric analog hardware needs, like balancing the charge on the two ends of an Ethernet cable. This all works so well that users never hear of it, and even most programmers don't know how it works.



'via Blog this'

Architecture: Microservices, Monoliths, and Modularity | Form Follows Function

Microservices, Monoliths, and Modularity | Form Follows Function: "MSAs can be useful when you need independently scalable and replaceable components. When you have multiple teams working on one logical application, they can also be appropriate as well. Using the technique when the cost outweighs the potential payoff, however, is a losing bet."



'via Blog this'

DefMacro: 44 engineering management lessons

44 engineering management lessons: "Welcome to engineering management. It’s fun, it’s exhausting, it’s rewarding — but most importantly it’s new! What worked for you before won’t work now. You’ll have to acquire a new set of skills, and shed some bad habits in the process. Here is a short guide to get you started."



'via Blog this'

Python Interface Design - Designing Modules Part - 1

Python Interface Design - Designing Modules Part - 1: "This is the first post in a multi-part series where we will design a reusable python module. "



'via Blog this'

The HTTP API Space Is Consolidating Around OAS

The HTTP API Space Is Consolidating Around OAS: "Currently, there are three main competing HTTP API specifications: Open API Specification (OAS) by Open API Initiative (OAI) – based on Swagger-, RAML with MuleSoft as main  contributor, and API Blueprint backed by Apiary which was bought by Oracle this year. While all three specifications have their own merits and tools built around, OAS has attracted the main support from the community after Swagger was entrusted to the Linux Foundation in 2015. OAS was supported from day one by 3Scale, Apigee, Google, IBM, Microsoft, and PayPal, among others."



'via Blog this'

The key differences between Python 2.7.x and Python 3.x with examples

The key differences between Python 2.7.x and Python 3.x with examples: "if you are starting a new project and have the choice to pick? I would say there is currently no “right” or “wrong” as long as both Python 2.7.x and Python 3.x support the libraries that you are planning to use. However, it is worthwhile to have a look at the major differences between those two most popular versions of Python to avoid common pitfalls when writing the code for either one of them, or if you are planning to port your project."



'via Blog this'

PWC: Machine learning methods (infographic)

Machine learning methods (infographic):

'via Blog this'

Some good "Statistics for programmers" resources - Julia Evans

Some good "Statistics for programmers" resources - Julia Evans: "One of the biggest problems with tests like the chi-squared test is that they make a lot of assumptions about how your data was generated. Usually they assume that your data is normally distributed. Not everything follows a normal distribution!

So – can I figure out if my change really made my code faster or not without having to make a bunch of assumptions?

It turns out the answer is “yes”, and that there’s a whole subfield of statistics devoted making less assumptions (“nonparametric statistics”). And even better – that subfield is actually easier to use than regular statistics."



'via Blog this'

Web: How to be best friend with the HTTP Cache ? | Blog Eleven Labs

How to be best friend with the HTTP Cache ? | Blog Eleven Labs: "Your application may have the best performance possible, you will always be limited by your physical machines – even if this is no longer true in the cloud (with an unlimited budget) – Consequently you must make friends with the cache.


Based on the experience that I have been able to accumulate on the subject and the numerous traps into which I have fallen, I will try to give you the best solutions for the use of the different caches."



'via Blog this'

TypeScript at Slack – Several People Are Coding

TypeScript at Slack – Several People Are Coding: "We decided to use Microsoft’s TypeScript, which combines static type analysis with a compiler. Modern JavaScript is valid TypeScript, meaning that one can use TypeScript without changing a single line of code. This allowed us to use “gradual typing” by enabling the compiler and the static analysis early, without suspending work on critical bug fixes or new features.
In practice, switching the analysis and the compiler on without changing code means that TypeScript will immediately attempt to understand your code"



'via Blog this'

Web: A Comprehensive Guide To HTTP/2 Server Push – Smashing Magazine

A Comprehensive Guide To HTTP/2 Server Push – Smashing Magazine: "Aside from solving common HTTP/1 performance problems (e.g., head of line blocking and uncompressed headers), HTTP/2 also gives us server push! Server push allows you to send site assets to the user before they’ve even asked for them. It’s an elegant way to achieve the performance benefits of HTTP/1 optimization practices such as inlining, but without the drawbacks that come with that practice.
In this article, you’ll learn all about server push, from how it works to the problems it solves. You’ll also learn how to use it, how to tell if it’s working, and its impact on performance. Let’s begin!"



'via Blog this'

POSIX Threads Synchronization in C | SoftPrayog

POSIX Threads Synchronization in C | SoftPrayog: "POSIX Threads provide multiple flows of execution within a process. The threads have their own stacks but share the global data and heap. So the global variables are visible to multiple threads. Also, the threads need to synchronize their actions so that they jointly realize the overall objectives of the process they belong to. The core problems of concurrent programming, mutual exclusion and synchronization are relevant for threads just like these problems are relevant for multi-process systems."



'via Blog this'

Queue implementation in C using linked list | SoftPrayog

Queue implementation in C using linked list | SoftPrayog: "A queue is a data structure with two end points, its head and the tail. Initially, the queue is empty. There are two basic operations available for a queue, enqueue and dequeue. The enqueue operation adds an element to the queue. Elements are added to a queue at its tail. The dequeue operation takes an element off the queue. The element at the head of a queue is dequeued. The elements are dequeued in the order they are enqueued making queue as a first-in, first-out (FIFO) data structure."



'via Blog this'

Interprocess communication using POSIX Shared Memory in Linux | SoftPrayog

Interprocess communication using POSIX Shared Memory in Linux | SoftPrayog: "Shared memory, message queues and semaphores form the suite of interprocess communication (IPC) mechanisms available under Linux and other Unix-like systems. In case of shared memory, the system provides a shared memory segment which the calling process can map to its address space. After that, it behaves just like any other part of the process's address space.



 If we look at the other IPC mechanisms like message queue or the older mechanisms like the pipe or the fifo, the work required for passing message involves, first copying the message from the address space of the first process to the kernel space via a send-like system call and, then, copying the message from the kernel space to the address space of the second process during a receive-like call. In the case of shared memory, the first process writes data in the shared memory segment and the data becomes available to the second process immediately. This makes shared memory faster than other mechanisms and is, in fact, the fastest way of passing data between two processes on the same host system"



'via Blog this'

C: It’s time for a memory safety intervention

It’s time for a memory safety intervention: "Programming in C means you are using an unsafe memory model 100% of the time. It is the programming equivalent of trying to walk a tightrope over a lake full of alligators while trying to avoid getting electrocuted by dangling power lines. The slightest mistake in your arithmetic at any one place in the code can be the difference between a perfectly safe program and remote code execution."



'via Blog this'

Linux: Bash scripting quirks & safety - Julia Evans

Bash scripting quirks & safety - Julia Evans: "Yesterday I was talking to some friends about Bash and I realized that, even though I’ve been using Bash for more than 10 years now there are still a few basic quirks about it that are not totally obvious to me. So as usual I thought I’d write a blog post"



'via Blog this'

C++: Writing a Linux Debugger Part 1: Setup

Writing a Linux Debugger Part 1: Setup:



'via Blog this'

MIT Structure and Interpretation of Computer Programs, 2e: Top

Structure and Interpretation of Computer Programs, 2e: Top:



The material in this book has been the basis of MIT’s entry-level computer science subject since 1980. We had been teaching this material for four years when the first edition was published, and twelve more years have elapsed until the appearance of this second edition. We are pleased that our work has been widely adopted and incorporated into other texts. We have seen our students take the ideas and programs in this book and build them in as the core of new computer systems and languages. In literal realization of an ancient Talmudic pun, our students have become our builders. We are lucky to have such capable students and such accomplished builders.

'via Blog this'

Docker/Containers demand new data center designs: 5 steps to survive | TechBeacon

Containers demand new data center designs: 5 steps to survive | TechBeacon: "Containers are gaining traction for production use in data centers, but data center architectures were not specifically designed to support them. This raises several questions.

Datadog reports massive adoption of Docker. Its study tracked 10,000 companies and their use of Docker and found that two-thirds of companies that try Docker end up adopting it. Additionally, those companies quintuple their usage after nine months.The report makes it clear: Things in the data center need to change. "



'via Blog this'

Donne Martin/system-design-primer: Learn how to design large-scale systems. Prep for the system design interview.

GitHub - donnemartin/system-design-primer: Learn how to design large-scale systems. Prep for the system design interview.: "Motivation

Learn how to design large scale systems.

Prep for the system design interview.
Learn how to design large scale systems

 Learning how to design scalable systems will help you become a better engineer.

System design is a broad topic.

There is a vast amount of resources scattered throughout the web on system design principles.

This repo is an organized collection of resources to help you learn how to build systems at scale."

'via Blog this'

Problem Solving with Algorithms and Data Structures using Python — Problem Solving with Algorithms and Data Structures

Problem Solving with Algorithms and Data Structures using Python — Problem Solving with Algorithms and Data Structures: "Problem Solving with Algorithms and Data Structures using Python"



'via Blog this'

Linux C/C++: Object Files and Symbols - Nick Desaulniers

Object Files and Symbols - Nick Desaulniers: "What was supposed to be one blog post about memory segmentation turned into what will be a series of posts. As the first in the series, we cover the extreme basics of object files and symbols. In follow up posts, I plan to talk about static libraries, dynamic libraries, dynamic linkage, memory segments, and finally memory usage accounting. I also cover command line tools for working with these notions, both in Linux and OSX."



'via Blog this'

Building Microservices with Python , Part I – Medium

Building Microservices with Python , Part I – Medium: "In this basic setup we are going to include those packages:

• Flask (as a Framework) 
• connexion (helpful tool to generate routes and Swagger docs) 
• Flask-Injector (Dependency Injection package)
•  Avro (or any data serialization package)

In this case, I chose Flask because I find it super useful to build small services without all the learning curve of Django. I just need something to help to do the routing and I will include whatever I need on it."



'via Blog this'

Building Microservices with Python , Part I – Medium

Building Microservices with Python , Part I – Medium: "In this basic setup we are going to include those packages:

• Flask (as a Framework) 
• connexion (helpful tool to generate routes and Swagger docs) 
• Flask-Injector (Dependency Injection package)
•  Avro (or any data serialization package)

In this case, I chose Flask because I find it super useful to build small services without all the learning curve of Django. I just need something to help to do the routing and I will include whatever I need on it."



'via Blog this'

Data structures and algorithms problems in C++ using STL and Java

Data structures and algorithms problems in C++ using STL: "Data structures and algorithms problems in C++ using STL"



'via Blog this'

Diagnosing and Fixing Memory Leaks in Python | Fugue

Diagnosing and Fixing Memory Leaks in Python | Fugue: "In the fall, our metrics reported that a Python component of Fugue called the reflector was experiencing random restarts and instability after a few days of uptime. Looking at memory usage showed that the reflector's memory footprint increased monotonically and continuously, indicating a memory leak. tracemalloc, a powerful memory tracking tool in the Python standard library, made it possible to quickly diagnose and fix the leak. We discovered that the memory leak was related to our use of requests, a popular third-party Python HTTP library. Rewriting the component to use urllib from the Python standard library eliminated the memory leak. In this blog, we'll explore the details."



'via Blog this'

Diagnosing and Fixing Memory Leaks in Python | Fugue

Diagnosing and Fixing Memory Leaks in Python | Fugue: "In the fall, our metrics reported that a Python component of Fugue called the reflector was experiencing random restarts and instability after a few days of uptime. Looking at memory usage showed that the reflector's memory footprint increased monotonically and continuously, indicating a memory leak. tracemalloc, a powerful memory tracking tool in the Python standard library, made it possible to quickly diagnose and fix the leak. We discovered that the memory leak was related to our use of requests, a popular third-party Python HTTP library. Rewriting the component to use urllib from the Python standard library eliminated the memory leak. In this blog, we'll explore the details."



'via Blog this'

CPython internals: A ten-hour codewalk through the Python interpreter so...

From dotCloud to Docker

From dotCloud to Docker: "This is a quasi-archeological account of some of the early design decisions of dotCloud, some of which have shaped how Docker is today (and how it is not). “How is this relevant to my interests?” you ask. If you are not using containers, and not planning to, ever, then this article will not be very useful to you. Otherwise, I hope that you can learn a lot from our past successes and failures. At the very least, you will understand why Docker was built this way."



'via Blog this'

C++ web: : Comparing The Performance Of Synchronous Versus Asynchronous Network IO

Comparing The Performance Of Synchronous Versus Asynchronous Network IO: "Given the popularity of certain asynchronous web servers, I’ve decided to use my first research post to look into performance comparisons between asynchronous and synchronous servers. All the benchmarks I’ve seen involve comparing different types of web servers to each other, without a clear apples-to-apples comparison between the two networking models. So, I’ve written two identical web-like servers: an asynchronous event-based server (async_server.cc) and a synchronous thread-based server (sync_server.cc). Both servers would clearly perform equally well handling a single-connection-at-a-time client, so the real test is to see how well each server performs while handling a large number of clients concurrently."



'via Blog this'

BuzzFeed Tech Blog - Introducing the Deep Exploration Series on Python

BuzzFeed Tech Blog - BuzzFeed News: "This post is the first in a series intended to dig deep into the Python interpreter. Python is a mature language, with commits dating back to August 1990. Along the way, the developers have evolved a series of processes for contributing that allow them to move relatively quickly with few issues/errors."



'via Blog this'

CodingGame

https://www.codingame.com "At CodinGame, we believe in a world where programming knowledge is free and accessible to everyone. Whether you are an industry speaker, a teacher, or a passionate programmer, we’re opening the platform collaborative architecture for you to create courses and demos on any kind of technology. Yes, any :)"



'via Blog this'

Hardware: AMD’s moment of Zen: Finally, an architecture that can compete | Ars Technica

AMD’s moment of Zen: Finally, an architecture that can compete | Ars Technica: "Before the company's new Zen offerings, it's fair to say that AMD's last attempt at building a performance desktop processor was not tremendously successful.

The Bulldozer core released in 2011 had a design that can, at best, be described as idiosyncratic. AMD made three bets with Bulldozer: that general purpose workloads would become increasingly multithreaded, that floating point intensive workloads would become increasingly GPU-driven, and that it would be able to aggressively scale clock speeds."



'via Blog this'

Security: GRC (Steve Gibson) Linkfarm | Nuts and Bolts of Encryption: A Primer for Policymakers

GRC | Linkfarm  : " "



'via Blog this'

charles leifer | Python: What happened? critique of python 3

charles leifer | What happened?: "Python 2.7 is a fantastic language for beginners and experts alike. It's so simple and readable that it's sometimes referred to as executable pseudo-code.

At some point a few years ago, things changed for the worse.

Did Python sell out? I don't know. Maybe Guido caved to some persuasive people with bad ideas. Maybe communists, wanting to reduce global productivity, railroaded through all these garbage PEPs. Maybe Python wanted to throw off its reputation as a toy language and become a serious language like Node.js... Whatever the case, when I look at all the PEPs that have been accepted over the past couple years, I can see that the inmates are now running the asylum."



'via Blog this'

A Simple Guide for Python Packaging – Medium

A Simple Guide for Python Packaging – Medium: "Code reuse is a very common need. It saves you time for writing the same code multiple times, enables leveraging other smart people’s work to make new things happen. Even just for one project, it helps organize code in a modular way so you can maintain each part separately. When it comes to python, it means format your project so it can be easily packaged. This is a simple instruction on how to go from nothing to a package that you can proudly put it in your portfolio to be used by other people."



'via Blog this'

API Design Guide | Cloud APIs | Google Cloud Platform

API Design Guide  |  Cloud APIs  |  Google Cloud Platform: "This is a general design guide for networked APIs. It has been used inside Google since 2014 and is the guide we follow when designing Cloud APIs and other Google APIs. It is shared here to inform outside developers and to make it easier for us all to work together.

External developers may find it particularly useful when designing gRPC APIs for use with Google Cloud Endpoints, and we strongly recommend such developers use these design principles. However, we don't mandate its use for any non-Google developer and you can use Cloud Endpoints and/or gRPC without following the guide.

This guide applies to both REST APIs and RPC APIs, with specific focus on gRPC APIs. gRPC APIs use Protocol Buffers to define their API surface and API Service Configuration to configure their API services, including HTTP mapping, logging, and monitoring. HTTP mapping features are used by Google APIs and gRPC Cloud Endpoints APIs for JSON/HTTP to Protocol Buffers/RPC transcoding."



'via Blog this'

business/startups: Chamath Palihapitiya – How we put Facebook on the path to 1 billion users | Genius

Chamath Palihapitiya – How we put Facebook on the path to 1 billion users | Genius: "
The takeaway from that were two things. One, and I'll get to this a little bit later, most people at most companies are really shit. That was manifested in large degree at AOL. I learned all the things not to do, one, and that was probably 90 percent of my learnings to be quite honest with you. Then 10 percent was reinforcing some things that I learned at Winamp which is really about core product value. What it means is create a real connection with someone. I think now we all euphemistically call it the “Aha” moment with the consumer. But also the power of how these communication networks when they develop create real entrenched usage and scale, and how these things can just dramatically accelerate adoption and engagement."



'via Blog this'

web: All JavaScript frameworks are terrible – Medium

All JavaScript frameworks are terrible – Medium: "A case study in confirmation bias and goalpost shifting

This article was originally written as a partnership with another one praising the virtues of all frameworks. It was intended to show in large part how easy it is to “spin” frameworks without ever being inaccurate. However, on working on both of them it was obvious to me that the other article was stronger, and I let this one wither on the vine. I’ve decided to finish it off and publish it, but need to reiterate. The other is the better article."



'via Blog this'

Linux: Getting the most out of Terminator | Al4

Getting the most out of Terminator | Al4: "Terminator is a must-have tool for Linux administrators. It’s a terminal emulator that supports multiple terminals via tabs, but also by dividing up its window with horizontal and vertical splits.

The user documentation is a bit sparse, in fact what you see in the man page is what you get. In this post I’ll take you through the features that I think make Terminator the best terminal emulator around."



'via Blog this'

ongoing by Tim Bray · Geek Career Paths

ongoing by Tim Bray · Geek Career Paths: "Sup­pose you’re do­ing tech­nol­o­gy, and like do­ing tech­nol­o­gy, and your career’s go­ing well, and you find your­self won­der­ing what you’re go­ing to be do­ing in twen­ty years. I’ve been down sev­er­al of the roads you might de­cide to take, and it oc­curs to me that talk­ing them over might amuse and in­for­m.

Thanks are due to An­dre Lei­bovi­ci, who tweet­ed Is it pos­si­ble to be in a sr. lead­er­ship po­si­tion and still be hands-on w/ tech & code? For geek lead­ers out there... how to jug­gle? and got me think­ing about this."



'via Blog this'

Data Science: The dirty secret of machine learning - O'Reilly Media

The dirty secret of machine learning - O'Reilly Media: ""Too many businesses now are pitching AI almost as though it's batteries included. I think that's dangerous because it's going to potentially lead to over-investment in things that overpromise. Then when they under-deliver, it has a deflationary effect on people's attitudes toward the space. It almost belittles the problem itself. Not everything requires the latest whiz-bang technology. In fact, the dirty secret of machine learning—and, in a way, venture capital—is so many problems could be solved by just applying simple regression analysis. Yet, very few people, very few industries do the bare minimum.""



'via Blog this'

What is the point of learning C? | CIO

What is the point of learning C? | CIO: "C is a fundamental language that is still in use in the IT industry. But that may change, says Mark Driver, a research analyst at Gartner. "They [C and C++] are the native tongue for system-level programming, and they probably will be for many years. Eventually, though, languages like Google Go or D may replace them."

"We see almost no demand for C or C++ among our IT centric clients," says Driver. "What we see is Java and other managed code languages being used," he says. "C doesn't allow you to address many modern architectural best practices, and the rise of languages such as Java and C# has been largely to address this."

But Driver says there's one rapidly growing area where there is likely to a be a huge demand for programmers with skills in C: the internet of things (IoT).  He says that the rise of IoT could lead to a huge revival in the need for small footprint codebases and runtimes. "For traditional workloads there is no need to be counting the bytes like there used to be. But when it comes to IoT applications there is that need once again. So we may well see a resurgence in demand for C skills.""



'via Blog this'

Statistics: Removing Outliers Using Standard Deviation in Python

Removing Outliers Using Standard Deviation in Python: "Removing Outliers Using Standard Deviation in Python"



'via Blog this'

Jupyter Notebook Viewer: Python "objects and types and metaclasses..."

Jupyter Notebook Viewer: "The Tao of Python
The intricate relationship between "object" and "type" and how metaclasses, classes and instances are related"



'via Blog this'

Using functional programming in Python like a boss: Generators, Iterators and Decorators

Jupyter Notebook Viewer: "Using functional programming in Python like a boss: Generators, Iterators and Decorators"



'via Blog this'

Google’s not-so-secret new OS — Tech Specs

Google’s not-so-secret new OS — Tech Specs: "I decided to dig through open source to examine the state of Google’s upcoming Andromeda OS. For anyone unfamiliar, Andromeda seems to be the replacement for both Android and Chrome OS (cue endless debates over the semantics of that, and what it all entails). Fuchsia is the actual name of the operating system, while Magenta is the name of the kernel, or more correctly, the microkernel. Many of the architectural design decisions appear to have unsurprisingly been focused on creating a highly scalable platform.

It goes without saying that Google isn’t trying to hide Fuchsia. People have clearly discovered that Google is replacing Android’s Linux kernel. Still, I thought it would be interesting for people to get a better sense of what the OS actually is. This article is only intended to be an overview of the basics, as far as I can comment reasonably competently. (I certainly never took an operating systems class!)"

"Proof"

Since writing my last piece, some Googlers reached out and said my assessment was largely right. The Andromeda part specifically was fairly inaccurate though, so I will try to rectify that.

Based on this code, it looks like Andromeda might be tied to free-form window mode for laptops and possibly tablets. Thus, as I wrote in my initial article, Andromeda + Fuchsia might launch initially only as a laptop platform. I think the app “chrome” will probably look like Android (because they will be Android or Flutter apps), but with floating windows and elements of or even an overall UI similar to Chrome OS. Supported inputs would be mouse or trackpad and keyboard, and possibly touch. Not wildly different from Chrome OS today, in other words. This may also explain the “Chrome OS will merge into Android” claim originally made by the Wall Street Journal. The underlying OS will still be Fuchsia, though.

Instead, I think for all Fuchsia devices, the Android API and runtime will continue to function as before, except now the underlying OS will be Fuchsia, and the kernel will be Magenta, not Linux. And then there would also be Mojo, Flutter, etc. at least starting on Andromeda devices. It’s hard to imagine pushing both the Mojo and Android APIs forever though, and Android will likely eventually (in several years) have to fade away.

Back to the more important point: yes, Fuchsia will be Google’s new OS underpinning all its consumer devices eventually. I think both a “Pixel 3” laptop (or whatever this hypothetical product would be called) and the Pixel 2 smartphone will probably run on Fuchsia, but I make zero promises as to anything shipping at any particular point in time, because I have no idea. Still, that is my suspicion based on public commits.

And again, if Google doesn’t break compatibility with the Linux user space, yes, it really can swap out the Android kernel (Linux) for Magenta/Fuchsia, and leave the Android API in its place. Standards like POSIX do exist, after all. Here is some code pointing to exactly that.

'via Blog this'

Software Engineering at Google. I like thinking about workflow and process, so this fascinates me. ht @craigcitro https://t.co/66dZtWTROE

— Jenny Bryan (@JennyBryan) February 12, 2017

Data Science/Society: The AI Threat Isn't Skynet. It's the End of the Middle Class | WIRED

The AI Threat Isn't Skynet. It's the End of the Middle Class | WIRED: "That said, these researchers say they are intent on finding the answer. “People work through the concerns in different ways. But I haven’t met an AI researcher who doesn’t care,” Etzioni says. “People are mindful.” But they feel certain that preventing the rise of AI is not the answer. It’s also not really possible—a bit like bringing those old manufacturing jobs back."



'via Blog this'

Monitor web page changes with Go

Monitor web page changes with Go: "In this article, we will look into how to create a program that will monitor web page changes using Go programming language with optional cookies header."



'via Blog this'

Web/IOT: Designing a True REST State Machine | Nordic APIs |

Designing a True REST State Machine | Nordic APIs |: "There are many misconceptions surrounding what exactly Representational State Transfer (REST) is. The prime of which is the concept of hypermedia, or defined in full context, Hypermedia as the engine of application state (HATEOAS).

Jargon aside, hypermedia is actually a valuable idea that many self-touted “RESTful” web APIs do not adhere to. Hypermedia places heightened operational significance on resources, located at URIs. With a hypermedia API, when a request is sent to a URI, the response lists information on resource state and acceptable future operations, in essence creating a state machine that can be manipulated.

Hypermedia is truly valuable as it can create more powerful APIs that alleviate the need for API versioning. But this is only one of many facets that makes true REST design awesome.

Today, we’re dedicating time to define what exactly REST is and isn’t.



Led by RESTafarian Asbjørn Ulsberg, we’ll uncover the history of information design that has led to REST, and debunk some common misinterpretations of REST design.

We’ll also construct a mock state machine and example HTTP behaviors, demonstrating how hypermedia could be used within a REST API to trigger states on an IoT kitchen device. Actually following the REST constraints by building a HATEOAS-compliant API could be very beneficial to advancing the web, so let’s give it the focus it deserves."

'via Blog this'

Functional Programming HOWTO — Python 3.6.0 documentation

Functional Programming HOWTO — Python 3.6.0 documentation: "In this document, we’ll take a tour of Python’s features suitable for implementing programs in a functional style. After an introduction to the concepts of functional programming, we’ll look at language features such as iterators and generators and relevant library modules such as itertools and functools."



'via Blog this'

Luciano Ramalho: Iteration & Generators: the Python Way

Arista: Networking Standards Move Too Slowly for Cloud Giants

Arista Founder: Networking Standards Move Too Slowly for Cloud Gi: "SANTA CLARA, California — The rise of the cloud titans has disrupted the comfortable standards cycles of the networking world and is — or at least should be — forcing the ecosystem to move faster, Arista Co-Founder Andy Bechtolsheim said during the opening talk at the Linley Cloud Hardware Conference today.

“Ten years ago, there was a single company dominating the space, and — let’s just say they didn’t have a motivation to go faster,” he said. “In the new world, it’s a fundamental change in the competitive environment.”"



'via Blog this'

elements-of-python-style/README.md at master · amontalenti/elements-of-python-style · GitHub

elements-of-python-style/README.md at master · amontalenti/elements-of-python-style · GitHub: "This document goes beyond PEP8 to cover the core of what I think of as great Python style. It is opinionated, but not too opinionated. It goes beyond mere issues of syntax and module layout, and into areas of paradigm, organization, and architecture. I hope it can be a kind of condensed "Strunk & White" for Python code."



'via Blog this'

Web/Javascript Polyfills and the evolution of the web - TAG finding

Polyfills and the evolution of the web - TAG finding: "Polyfills are a valuable part of Web architecture, because they promote the adoption of new features during the implementation process. However, polyfills can also create problems for standardization efforts and therefore for the future of the Web. This document defines the risks, benefits, and role of polyfills on the Web, and proposes best practices for implementors, spec editors, website developers, polyfill authors, and operators of polyfill distribution platforms."



'via Blog this'

Monitoring and Tuning the Linux Networking Stack: Sending Data - Packagecloud Blog

Monitoring and Tuning the Linux Networking Stack: Sending Data - Packagecloud Blog: "This blog post explains how computers running the Linux kernel send packets, as well as how to monitor and tune each component of the networking stack as packets flow from user programs to network hardware.

This post forms a pair with our previous post Monitoring and Tuning the Linux Networking Stack: Receiving Data."



'via Blog this'

intermezzOS: a little OS - Systems Programming : rust

intermezzOS: a little OS: "intermezzOS is a teaching operating system, specifically focused on introducing systems programming concepts to experienced developers from other areas of programming."



'via Blog this'

Daniel Allen Deutsch: Linux/Unix: Using tmux Properly

Daniel Allen Deutsch: "I've been using terminal multiplexers for a few years, but never properly.

In the beginning, it was just me and the (plain) terminal. Then I started using Byobu, because it was company-standard at my first job. Later I installed tmux on my personal computer because it seemed more popular. And every time I work on a remote server, I use Screen. Lions and tigers and bears, oh my!

This begs a few of questions. We'll go through them in the next section.

As a quick aside before we dive in—'terminal multiplexer' is an intimidating term. But none of the concepts are complex. Terminal means console and multipexing is just running numerous processes at the same time in one place."



'via Blog this'

Rewriting Duolingo's engine in Scala | Making Duolingo Blog

Rewriting Duolingo's engine in Scala | Making Duolingo Blog:

Recently, we profoundly refactored the engine that drives Duolingo lessons. This post talks about our engineering choices, experiences, and the pain points of rewriting a highly complex system.

• 
  
• Highlights:
• Redesigned architecture
• Refactored code from Python to Scala
• Latency dropped from 750ms to 14ms
• Engine uptime increased from 99.9% to 100%

'via Blog this'

Google Python Style Guide

Google Python Style Guide: "Python is the main scripting language used at Google. This style guide is a list of dos and don'ts for Python programs.

To help you format code correctly, we've created a settings file for Vim. For Emacs, the default settings should be fine."



'via Blog this'

Java Performance: The JVM is not that heavy - Open Sourcery

The JVM is not that heavy - Open Sourcery: "Be very careful before judging the JVM as a target. Judge Java as a language by all means, but keep it separate from the virtual machine.

I used to believe the same things you did. I used to think of the JVM as this behemoth. Now I'm thankful to be able to throw my parentheses at it and have the work of thousands of giants support it.

By no means take this post as a sign of "the end of Node" or "the end of Ruby". Let it bring a fresh perspective. If you can't switch to the JVM, at least think about what you could do to help eliminate the bloat from your own world.

"



'via Blog this'

Introduction to Machine Learning with Python

Introduction to Machine Learning with Python: "Machine learning has long powered many products we interact with daily–from "intelligent" assistants like Apple's Siri and Google Now, to recommendation engines like Amazon's that suggest new products to buy, to the ad ranking systems used by Google and Facebook. More recently, machine learning has entered the public consciousness because of advances in "deep learning"–these include AlphaGo's defeat of Go grandmaster Lee Sedol and impressive new products around image recognition and machine translation.

In this series, we'll give an introduction to some powerful but generally applicable techniques in machine learning. These include deep learning but also more traditional methods that are often all the modern business needs. After reading the articles in the series, you should have the knowledge necessary to embark on concrete machine learning experiments in a variety of areas on your own."



'via Blog this'

The Infrastructure Behind Twitter: Scaling Networking, Storage and Provisioning

The Infrastructure Behind Twitter: Scaling Networking, Storage and Provisioning: "By late 2010 Twitter had finalised their first in-house network architecture that was designed to address scale and service issues that were encountered with the existing third-party colocated infrastructure. Initially, the use of deep buffer Top of Rack (ToR) switches, and carrier-grade core network switches allowed Twitter to support previously unseen transaction per second (TPS) volumes that were generated as a result of global events such as the World Cup Football in 2014. However, over the next several years the Twitter infrastructure team added network point-of-presence (PoPs) over five continents, and in 2015 Twitter moved from a traditional hierarchical data center network topology to a Clos network using Border Gateway Protocol (BGP) for routing. Highlights of the Clos approach include a smaller 'blast radius' of a single device failure, horizontal bandwidth scaling capabilities, and higher route capacity due to lower CPU overhead."



'via Blog this'

Is there still a business case for private cloud? – Cloud Technology Partners - Linkis.com

Is there still a business case for private cloud? – Cloud Technology Partners - Linkis.com:


Despite the increasing popularity of public cloud’s on-demand, pay-per-use model, private cloud still has a place in the enterprise, and its adoption continues to grow across platforms. There remains legitimate reasons to own and manage your own technology infrastructure, and private clouds bring some of the benefits of cloud principles to such data center deployments.


For Episode 100 of The Doppler podcast, David Linthicum sat down with private cloud proponent John Engates, and private cloud skeptic Bernard Golden to moderate a discussion around the future of private cloud and its business value in IT’s dynamic landscape.

'via Blog this'

http://www.liuchengxu.org: how to use vim as a python ide

how to use vim as a python ide: "I love vim and often use it to write Python code. Here are some useful plugins and tools for building a delightful vim python environment, escpecially for Vim8:"



'via Blog this'

Introduction · A Guide to Porting C and C++ code to Rust

Introduction · A Guide to Porting C and C++ code to Rust: "This book is for people familiar with C or C++ who are thinking of using Rust.
"

Normally such software would be written in C or C++, but consider these every day programming issues that afflict these languages:

• Dangling pointers. A program calls an invalid pointer causing a crash.
• Buffer overruns / underruns. Code writes beyond an allocated buffer causing memory corruption or a page exception.
• Memory leaks. Code that allocates memory without calling the corresponding free action.
• Data races. Multiple threads write to data at the same time causing corruption or other destabilizing behavior.

Rust stops these bad things happening by design. And it does so without impacting on runtime performance because all of these things are checked at compile time...

'via Blog this'

How to free disk space on Linux systems - TechRepublic

How to free disk space on Linux systems - TechRepublic: "The Linux operating system is well known for its powerful command line functionality. As a system administrator, I operate a few hundred Linux servers and most of them don't even utilize a graphical user interface such as KDE or Gnome. Maintenance of our servers requires extensive knowledge of various helpful (yet complex) commands to keep them healthy.

Disk space is frequently a headache with systems that store and write a lot of data (some useful, and some not). While QDirStat, GdMap, xdiskusage and Gnome's Disk Usage Analyzer are all useful examples of graphic-based utilities to measure disk space usage, I have a toolkit of my own commands which I use from the command line and it's safe to say they're indispensible to me. Here are a few of my favorite examples."



'via Blog this'

4 essential skills software architects need to have but often don’t - O'Reilly Media

4 essential skills software architects need to have but often don’t - O'Reilly Media: "Microservices. Continuous delivery. Reactive systems. Cloud native architecture. Many software architects (or even aspiring ones) have at least a passing familiarity with the latest trends and developments shaping their industry. There are plenty of resources available for learning these topics, everything from books and online videos to conference presentations; the ability to go from novice to expert in these areas is right at their fingertips. However, as today’s trends quickly bleed into tomorrow’s standards for development, it’s paramount that software architects become change agents within their organizations by putting into practice the “unspoken” side of their skill set: communication and people skills"



'via Blog this'

RipVanWinkle.js — Returning to JavaScript After 5 Years

RipVanWinkle.js — Returning to JavaScript After 5 Years: "I got JavaScript fatigue before it was fashionable, way back in 2011. I basically ignored the entire ecosystem — including Node — in the interim, while happily programming away in Python 3 and its excellent stats libraries.
This past year, a number of great summaries of the JavaScript ecosystem were published, including the quite critical How it feels to learn JavaScript in 2016. In reading these articles, I realized that everything I knew about JavaScript and its platform was just completely out-of-date. ES2015? Arrow functions? Transpilers? Babel? React?
It was like people were talking in a foreign language — and they were, for the JavaScript I had grown up with was dead, and had been replaced with something far better (although still with quirks)."



'via Blog this'

SKIDL | PYTHON → CIRCUITS

SKIDL | SKIDL: "Never use a lousy schematic editor again! SKiDL is a simple module that lets you describe electronic circuits using Python. The resulting Python program outputs a netlist that a PCB layout tool uses to create a finished circuit board."



'via Blog this'

technologyreview: Programming Languages: Toolkits for the Mind

Toolkits for the Mind: "When the Japanese computer scientist Yukihiro Matsumoto decided to create Ruby, a programming language that has helped build Twitter, Hulu, and much of the modern Web, he was chasing an idea from a 1966 science fiction novel called Babel-17 by Samuel R. Delany. At the book’s heart is an invented language of the same name that upgrades the minds of all those who speak it. “Babel-17 is such an exact analytical language, it almost assures you technical mastery of any situation you look at,” the protagonist says at one point.



With Ruby, Matsumoto wanted the same thing: to reprogram and improve the way programmers think.

It sounds grandiose, but Matsumoto’s isn’t a fringe view. Software developers as a species tend to be convinced that programming languages have a grip on the mind strong enough to change the way you approach problems—even to change which problems you think to solve. It’s how they size up companies, products, their peers: “What language do you use?”



 That can help outsiders understand the software companies that have become so powerful and valuable, and the products and services that infuse our lives. A decision that seems like the most inside kind of inside baseball—whether someone builds a new thing using, say, Ruby or PHP or C—can suddenly affect us all. If you want to know why Facebook looks and works the way it does and what kinds of things it can do for and to us next, you need to know something about PHP, the programming language Mark Zuckerberg built it with."



'via Blog this'

Why I Switch From [Language_1] to [Language_2]

Why I Switch From [Language_1] to [Language_2]: "I am a big fan of [Language_1] and one of its early adopters, having been disappointed with the utter failures of [Language_0]. I have been an avid contributor to many open source projects such as [Obscure_Project_1], [Obscure_Project_2], and [Obscure_Project_3]. However, after using [Language_1] for over 5 years, I have been dealing with [Minor_Technical_Flaws]. At first, I ignored and even tolerated these flaws, but I was forced to confront reality. I could not live with these flaws, and since [Language_1] is a mature language, it will be difficult, if not impossible, to actually fix [Minor_Technical_Flaws]."



'via Blog this'

“My Code is Self-Documenting” — Eric Holscher - Surfing in Kansas

“My Code is Self-Documenting” — Eric Holscher - Surfing in Kansas: "Self-documenting code is one of the biggest documentation myths in the software industry. This view generally conflates documentation with code comments. I’d like to make two arguments in this post:

Code comments have value
Documentation has more value than just explaining how software works"



'via Blog this'

Original Rust introductory slidedeck

http://venge.net/graydon/talks/intro-talk-2.pdf



'via Blog this'

Google Infrastructure Security Design Overview | Google Infrastructure Security Design Overview | Google Cloud Platform

Google Infrastructure Security Design Overview  |  Google Infrastructure Security Design Overview  |  Google Cloud Platform: "  Google has a global scale technical infrastructure designed to provide security through the entire information processing lifecycle at Google. This infrastructure provides secure deployment of services, secure storage of data with end user privacy safeguards, secure communications between services, secure and private communication with customers over the internet, and safe operation by administrators.
Google uses this infrastructure to build its internet services, including both consumer services such as Search, Gmail, and Photos, and enterprise services such as G Suite and Google Cloud Platform.



The security of the infrastructure is designed in progressive layers starting from the physical security of data centers, continuing on to the security of the hardware and software that underlie the infrastructure, and finally, the technical constraints and processes in place to support operational security.
Google invests heavily in securing its infrastructure with many hundreds of engineers dedicated to security and privacy distributed across all of Google, including many who are recognized industry authorities.
Introduction

This document gives an overview of how security is designed into Google’s technical infrastructure. This global scale infrastructure is designed to provide security through the entire information processing lifecycle at Google.


'via Blog this'

xkcd: Functional Programming

xkcd: Sad: "

'via Blog this'

Making the move from Scala to Go, and why we're not going back | Movio Movio Blog

Making the move from Scala to Go, and why we're not going back | Movio Movio Blog: "Here’s the story of why we chose to migrate from Scala to Go, and gradually rewrote part of our Scala codebase to Go. As a whole, Movio hosts a much broader and diverse set of opinions, so the “we” in this post accounts for Movio Cinema’s Red Squad only. Scala remains the primary language for some Squads at Movio."



'via Blog this'

Short intro to C++ for Rust developers: Ownership and Borrowing

Short intro to C++ for Rust developers: Ownership and Borrowing: "ince I got C++ job after learning Rust, I thought it would be interesting to write a summary how one would adapt to C++ with some prior Rust experience.

I would assume the reader already knows C++ syntax and features, and would be interested in how one would fit concepts to C++ from Rust world.

In this post, however, I could not fit everything I wanted to write, so I will focus on Ownership, Borrowing and Lifetimes."



'via Blog this'

Dismissing Python Garbage Collection at Instagram

Dismissing Python Garbage Collection at Instagram: "By dismissing the Python garbage collection (GC) mechanism, which reclaims memory by collecting and freeing unused data, Instagram can run 10% more efficiently. Yes, you heard it right! By disabling GC, we can reduce the memory footprint and improve the CPU LLC cache hit ratio. If you’re interested in knowing why, buckle up!"



'via Blog this'

Scaling Python is on its way | Julien Danjou

Scaling Python is on its way | Julien Danjou: "I started to dig into a lot of different fields around Python. Topics you don't often look at when writing a simple and straight-forward application. It turns out that writing scalable applications in Python is not impossible, nor that difficult. There are a few hiccups to avoid, and various tools that can help, but it really is possible – without switching to another whole language, framework, or exotic tool set.

Working on those projects seemed to me like a good opportunity to share with the rest of the world what I learned. Therefore, I decided to share my most recent knowledge addition around distributed and scalable Python application in a new book, entitled The Hacker's Guide to Scaling Python (or Scaling Python, in short). The book should be released in a few months – fingers crossed."



'via Blog this'

WestMonroe: A Beginner’s Guide to Leaf-Spine Networking Topology

A Beginner’s Guide to Leaf-Spine Network Topology: "There is a new trend for network topology design standards — creating a fast, predictable, scalable, and efficient communication architecture in a data center environment. This article provides an introduction to Leaf-Spine network topology."



'via Blog this'

Learning systems programming with Rust - Julia Evans

Learning systems programming with Rust - Julia Evans: "I did the closing keynote at the first RustConf yesterday, on Rust and systems programming and accessibility and learning about concurrency and why I write about programming and a bunch of other things.

I was really delighted to be invited because I’m a huge fan of the Rust community. They’re working incredibly hard to make a language that is extremely powerful, but also easy to use, and there was a huge focus on usability and good error messages. The talks were really ambitious, friendly, and inclusive. Their challenge is “Fast, safe, productive – pick three” :).

Here’s a video & transcript of that talk (where when I say “transcript” I mean “more less what I said, kinda”)."



'via Blog this'

Linux kernel initialization, translated to bash · GitHub

Linux kernel initialization, translated to bash · GitHub: "Linux kernel initialization, translated to bash"

'via Blog this'

Google Open Source Blog: Grumpy: Go running Python!

Google Open Source Blog: Grumpy: Go running Python!: "Grumpy is an experimental Python runtime for Go. It translates Python code into Go programs, and those transpiled programs run seamlessly within the Go runtime. We needed to support a large existing Python codebase, so it was important to have a high degree of compatibility with CPython (quirks and all). The goal is for Grumpy to be a drop-in replacement runtime for any pure-Python project.
Two design choices we made had big consequences. First, we decided to forgo support for C extension modules. This means that Grumpy cannot leverage the wealth of existing Python C extensions but it gave us a lot of flexibility to design an API and object representation that scales for parallel workloads. In particular, Grumpy has no global interpreter lock, and it leverages Go’s garbage collection for object lifetime management instead of counting references. We think Grumpy has the potential to scale more gracefully than CPython for many real world workloads"

'via Blog this'

Porting Python 2 Code to Python 3 — Python 3.6.0 documentation

Porting Python 2 Code to Python 3 — Python 3.6.0 documentation: "A key point about supporting Python 2 & 3 simultaneously is that you can start today! Even if your dependencies are not supporting Python 3 yet that does not mean you can’t modernize your code now to support Python 3. Most changes required to support Python 3 lead to cleaner code using newer practices even in Python 2 code.

Another key point is that modernizing your Python 2 code to also support Python 3 is largely automated for you. While you might have to make some API decisions thanks to Python 3 clarifying text data versus binary data, the lower-level work is now mostly done for you and thus can at least benefit from the automated changes immediately.

Keep those key points in mind while you read on about the details of porting your code to support Python 2 & 3 simultaneously."

'via Blog this'

Getting Past C : Rust / Go

Getting Past C: "Now for the exciting questions: which language, and when?

We don’t have answers to those yet, but the field is narrowing and the time we might attempt a translation is getting closer - in the most optimistic case it could be as little as 6 to 9 months out. The catalyzing event is not just the emergence of two plausible candidate languages but the fact that both seem now to have reached a self-sustaining community size, so we can be reasonably confident they won’t croak and leave us stranded.

No prize for guessing that our two plausible candidates are Go and Rust.

There’s lots of web evangelism around both languages, so I’m not going to attempt a detailed comparison here. I’m just going to hit a few high points about how their traits intersect with NTPsec’s particular needs.

Probably the first question that will occur to a lot of you is: "Huh? Wouldn’t the stop-the-world pauses from garbage collection rule out Go? And the answer is…​they might, but (a) the actual time-critical sections in NTP are small and wrapped tightly around the clock-manipulation calls, and (b) Go’s runtime allows you to lock out GC during critical sections.

In any case, the Go developers have a pretty convincing story about holding stop-the-world pauses down to the small-number-of-milliseconds range. We’ll have to measure, but that just might be tolerable even without the GC lockout.

Still, the absence of GC overhead is a point in Rust’s favor. So is Corrode, the automatic C-to-Rust translator. The Go developers wrote a translator to move their Go compiler from C to Go, but it has no documentation and "Here Be Dragons!" warnings in the README.

Russ Cox’s talk on the C-to-Go translator claims it handles a large subset of C that notably does not include…​unions and certain kinds of goto. These are restrictions we can deal with. It may be usable. And if it’s not, maybe I can up-gun it until it is - language parsing and translation is a kind of problem I’m pretty good at and enjoy working.

In the end it might come down to which language I feel more comfortable in. (It’s good to be king the principal coder at times like this.) And I don’t know which that’ll be yet."

'via Blog this'

The memory models that underlie programming languages

The memory models that underlie programming languages: "There are about six major conceptualizations of memory, which I’m calling “memory models”², that dominate today’s programming. Three of them derive from the three most historically important programming languages of the 1950s — COBOL, LISP, and FORTRAN — and the other three derive from the three historically important data storage systems: magnetic tape, Unix-style hierarchical filesystems, and relational databases.

These models shape what our programming languages can or cannot do at a much deeper layer than mere syntax or even type systems. Mysteriously, I’ve never seen a good explanation of them — you pretty much just have to absorb them by osmosis instead of having them explained to you — and so I’m going to try now. Then I’m going to explain some possible alternatives to the mainstream options and why they might be interesting."

'via Blog this'