jake_morrison

The company seems to be mixing up things that should be separate. The major challenges when you have a lot of junior developers is having enough seniors to manage them and work that is appropriate for them to do.

Andela raised a lot of money based on social justice capital, which is fine. The problem is that consulting is not a particularly good way to spend it. The best strategy, I think, is to combine a school, consulting company and a venture capital operation.

The school may be more or less self supporting, paid for by students or with scholarships. It can be challenging keep programmers engaged as teachers, as they can make good money for less hassle, and they need to have a particular set of interpersonal and teaching skills which is rarer in programmers. Subsidy can help to set up the school and pay teachers well.

The consulting company is a for-profit enterprise, and needs to have the right balance of skills, not too many juniors. The best graduates of the school may be hired by the consulting company.

The VC operation funds business opportunities executed using local tech teams. The business side might be local, targeting an opportunity in Africa, or remote. The VC provides seed funds for a large number of projects, and the consulting company executes. The seed round gives them money to develop an initial product and test the market. Then they are evaluated and may get another round or shut down. If they move forward, then the developers continue working full time with the startup, otherwise they go back into the consulting pool for another project.

This provides a nice, sustainable synergy between the parts. The consulting company gets a continuous stream of projects without a lot of risk. The school graduates get practical experience supervised by seniors, then a potential full time job. The seed VC gets early access to good deals, and some will work out well.

The system is financially self supporting, but can take advantage of subsidies or overseas investment.

The key problem in all of this is actually delivering projects with junior people, which means you need to make it attractive for senior people to get involved and stay engaged. They need to be paid well or have some significant share of the upside.

With the virus, we are entering a new age of remote work which will open up opportunities for people around the world. It is difficult for companies in the US to identify, nurture and manage remote talent in emerging markets. In some sense, that's the primary value of the consulting company, but it needs to be part of an ecosystem.

I have two daughters in college.

My older daughter just graduated in mathematics / machine learning from UCLA. Online classes were mostly ok, though there were some comical situations where the professor taught the whole class with his microphone on mute.

Her exams were really rough, though. The math professors were unwilling to make any accommodation for the virus. While in quarantine with demonstrations and national guard soldiers literally across the street, she was taking exams. Everyone had 24 hours to take the exams, so they made them extra hard. They graded on a curve, because taking that away would be sacrilegious. So you have a choice, either spend as much of 24 hours as possible on the test, cheat (like some groups of students did), or get a bad grade. And then she had three exams in the same 24 hour period. The goal of testing should be to ensure that you know the material, not this competition shit.

My younger daughter is studying at USC. She came back to Taiwan last semester, so she hasn't needed to deal with the virus. Online classes have been pretty chaotic, though. Watching async videos has actually been a plus, but the mandatory discussion sections at 3 AM have been rough. It would be nice if they would just open one up in Asia timezone. Especially because students from China are now blocked from going back to the US.

USC was planning to have everyone come back on campus next semester, but just canceled because their opening plan was rejected by LA government. I am happy that she will be safe.

Universities are really worried about their business model, and are willing to have people die to preserve it.

I am a programmer. All the software that I run is cross platform, so I expect a smooth transition.

Elixir, my main programming language, will use all the cores in the machine, e.g. parallel compilation. Even if an ARM-based mac has worse per-core performance than Intel, I am ahead.

Apple can easily give me more cores to smooth the transition. Whatever the profit margin was for Intel on the CPU, they can give it to me instead. And they can optimize the total system for better performance, battery life and security.

The compatible problem is Microsoft and Safari, not Chromium and Firefox. I run a web development agency, and supporting the limitations IE has always been a significant cost and challenge. As the joke goes, "What is the definition of HTML5? If it works in IE, it's not HTML5".

I have mixed feelings about Microsoft giving up on their browser. On the one hand, it will make things more compatible and reduce effort for us. On the other, it's one step closer to a monoculture controlled by Google. I would prefer that Microsoft simply get their shit together and make a good browser.

I think we need a common online learning platform for K-12.

That at least gives everyone the same access to the best lecturers, independent of the low education budgets from poorer areas, as well as e.g. AP classes that they can't get locally.

It reduces the need for "redundant" teachers there just to deliver a mediocre lecture. Teachers are still needed to provide individual help, something that doesn't scale as easily as online lectures. That could be done locally or remotely.

Students need a computer and internet access. Providing them with that is cheaper than trying to fund local teachers and buildings, though.

Then we need some way to provide the social aspects provided by schools, sports, chemistry labs, as well as all the other services like food and counseling which are not part of education but are provided by the school system.

The same thing applies to the university system. I think this is the way out of the current cost explosion/bubble.

This was sort of true when computers had few CPUs/cores. It didn't make much of an efficiency difference, it was mostly a question of programming model. It works fine as long as the program is fundamentally I/O bound, but breaks down when it is doing actual work and becomes CPU bound.

I have certainly had some horrible experiences debugging multi-threaded C++ programs, and using non-blocking I/O made them safer and easier to reason about because only one thing happens at a time. The non-blocking I/O programming paradigm, however exposes unnecessary "plumbing" to the programmer.

What we really want is a concurrency model where we can handle each request as if it was the only thing happening.

To the extent that multiple requests need to share resources, we need ways to safely access state with concurrent access. That might be a relational database, mutexes, or software transactional memory.

I am currently in the middle of updating a large application written in Twisted Python. async/await and promises can certainly be complex. The Flask approach of using one thread per request is easier to understand. Everyone in the Javascript is in love with async/await, but I can see where that ends: just look at what Twisted was doing 10 years ago. And see that it basically failed due to complexity.

The model I like best is Erlang/Elixir. The runtime handles I/O using non-blocking I/O and threads to be efficient. The programmer works in terms of lightweight actors (called "processes", more like Java "green threads") that communicate using message passing. Each individual Erlang process only does one thing at a time.

As Joe Armstrong, one of Erlang's inventors, says: "We do not have ONE web-server handling two million sessions. We have two million webservers handling one session each." https://joearms.github.io/published/2016-03-13-Managing-two-...

Message passing handles concurrency without locks. If multiple client processes send update messages to a server, the server simply pulls them from its inbox in order and updates the shared state it is responsible for. The VM schedules processes preemptively, handling millions without breaking a sweat. It's safe, because one process can't mess with another process's memory. It is easy to reason about and debug.

It easily takes advantage of all the CPUs on the server. You can run a single VM instead of breaking up your application into multiple servers, each of which only uses one CPU (via containers or OS processes) and trying to coordinate between them. The VM has a built-in key/value store with efficient concurrency. It's like Redis but without the serialization overhead, so a read takes 1 microsecond.

Big fan of terragrunt.

The fundamental model behind Terraform is declarative. You use the Terraform language to define resources for your target system, e.g. a load balancer in AWS. You then run Terraform and it checks the desired configuration vs the running configuration, and it shows the differences. If the new config is what you want, you apply the changes, and it updates the production system.

Ansible is much more of an imperative system, sort of "executable YAML". You define a series of tasks in a YAML file. There are predefined tasks for standard things that you need to do when configuring a system, e.g. creating a directory or generating a config file by merging Ansible configuration variables with template. You can and should make these tasks idempotent, but as the system gets more complex, it becomes difficult and runtime can be slow as it compares tasks one by one to the running system.

Both systems suffer somewhat from difficulty in writing code. The fundamental task is to transform configuration variables and templates into running resources. To do that, you need loops, if/then/else logic, etc. Ansible has some constructs, but it is basically string manipulation, with a backdoor of being able to write modules in python. Terraform has a better syntax to define resources. Logic is generally things like ternary operator and list comprehensions. Terraform 0.12 improved this tremendously, but it is still somewhat weak. Ansible has a bit better management of config variables. Terraform tends to make you serialize things through environment vars, and it's awkward to define structure sometimes. Both would benefit greatly from first class functions and programming logic, even as they are "functional", just transforming data.

I love them both, and I hate them both. Terraform is best for provisioning complex infrastructure. Ansible is great for setting up instances, and it's easy for everyone to understand, dev and ops. Here is a complete example of deploying a complex, full-featured app to AWS using Terraform and Ansible: https://github.com/cogini/multi-env-deploy

I feel like we are suffering through a period where the tools are immature. People are focusing on syntax, but we are missing fundamental parts of the way the system should work. https://www.cogini.com/blog/is-it-time-for-lisp-in-devops/

The exact same thing is going on in the Kubernetes world. Back in the .com days, we would laugh at the "HTML programmers", but now we are "YAML programmers".

There are a couple of fundamental ways of managing the new cloud systems, all of which are better or worse depending on what you are doing. There are declarative systems like Terraform or CloudFormation. There is imperative with tasks, like Ansible. There are things that talk directly to the API like boto. There are tools like Pulumi which take a library approach in a general purpose programming language. Dockerfiles are crying out for higher level solutions, which are being developed. Ultimately I like the approach of a dedicated syntax like Terraform, but with more programming capability, or Pulumi.

In one memorable project the hardware guys grudgingly agreed to waste money and give the system enough resources to run Linux.

But they chose a cheaper ARM CPU without a MMU or hardware floating point. That meant it would not run shared libraries, everything was statically linked. We ran out of space in the Flash, and the project was in crisis. The solution was using a lua interpreter.

These days, I like high level platforms like Nerves: https://www.nerves-project.org/

Embdded development is like this sometimes.

Start with some hardware. If you are lucky, you get a board support package with a Linux kernel. Otherwise you need to write some drivers to talk to the hardware. Progressively get it to the point that it will boot up and get on the network. Then get the application running.

Microcontroller development is even worse. When you don't have any space, you may actually end up writing everything in C from scratch.

One of my favorite job interview questions for sysadmins is asking about a time that they screwed up and broke production. If they don't have one, then it makes me nervous. Either they are lying, or they don't have enough experience, or they will be too conservative and will block all progress.

Read that as "waterboarding" :-)

Scrum is for when you have a central dev team in a company that's shared between multiple groups. Once every sprint, you get all the managers in a room and let them fight it out. The result is a list of features that will be in the sprint. Everyone more or less gets their turn, depending on how powerful they are and whether something is legitimately urgent. Even if something is urgent, they can probably wait two weeks if they don't get it in this sprint. The dev team gets to work on something without interruptions for two weeks. The alternative is having everyone pushing around the devs, continuously changing requirements, overloaded devs, and general chaos.

There is a fundamental relationship between schedule duration, amount of work and quality.

If estimates were all accurate, then the amount of work and the sprint duration would be the same. It inevitably takes more work than estimated, so something has to give.

If you constrain the duration and the scope of work, then quality will vary. If you constrain the duration and allow overtime, then you get a mini crunch time every two weeks. Some bosses think that people will slack off unless they are given pressure, so they like this situation.

A better way is Kanban. It's more or less Scrum where quality is the thing that's fixed. If the task is going to make more time than originally estimated, either you let it take more time or reduce the size of the feature, i.e. implement a simpler version of it.

I am a consultant working in a distributed team, often remote from our client. I find the standup format to be very useful, often delivered via a daily email.

While we use a formal issue tracker like Jira which handles approvals and estimates, from a project management perspective it's useful to have a summary email that is short enough for people to read and focused on business level issues.

"Today I worked on this" / "Next I plan to work on that." This helps clients to see exactly what we are working on. It avoids miscommunication where we think they told us to prioritize something different, or they thought they told us to stop work on something, or they think we are finished with something and we are not. Having an email every day lets them tell us to stop work immediately if we are doing the wrong thing, avoiding surprise invoices the next month. It avoids them claiming that they didn't know that we were working on something.

"Here are the problems I am having / things I need from you". This is very useful to keep track of delays caused by the client. This might be them needing to review and accept work, review specs, or pay their invoices. Issues stay on the report until they are resolved. It documents that we didn't get what we needed, so we can't be blamed for things being late.

The most interesting use case for Dropbox is enabling cross-app workflows on iPad. Most apps support the Dropbox APIs now. Apple needs to get its shit together and make iCloud the back end. They can mandate that apps support their APIs, and then iCloud gets more revenue.

Something built into my Apple watch, maybe, that's my "notification" device. And it would be nice if it didn't cost $10/month to the carrier.

I was working at British Telecom when they bought their 3G licenses for the UK. The stock dropped by 50%, making my options worthless. Not that I am salty.

I wonder if it is optimum for society to price the spectrum so high that it is barely possible to build on it, then transfer the costs to the consumer. Basically it's a tax on technology. Or if it's not so high, then it's a windfall to the carriers.

I am not talking about using the pager network for that, I am talking about the 2G network.

I am not opposed to using more efficient network protocols, more that we are endlessly replacing old technologies with completely new systems. The selling point of 3G/4G/5G has been that they will have more bandwidth, so people can watch videos or use self driving cars.

What is more interesting to me is embedding cheap low-bandwidth smarts in more devices. The costs of the new and immature hardware gets in the way of that.

If I am sending 100 bytes, then spectral efficiency is not my biggest problem.

NB-IoT is fine, I will have to use it. The cost of 4G/5G chips is a lot higher than older generations, to say nothing of what would happen if anyone can make chips.

Everyone just wants to sell me something new, because that's how they make money. When 3G came out all the telecoms were excited to sell video, as it would give higher average revenue per user. Turns out people don't want to pay more.

We get faster networks but keep the same price per GB, so with 5G I will be able to blow through my monthly bandwidth in 60 seconds. And that assumes that the carriers have the backbone capacity.

It is funny to see these technologies being shut down right when they are useful for IoT.

I was building LED displays for bus stops to show information about the next bus. I found pagers to be a great match: cheap chips with integrated support for communications and displays, low costs for small text messages, great network coverage. But then the telecoms started shutting down the networks.

Now we are seeing the same thing with the push to 5G. I don't want 5G, I want 2G. Before there was TCP/IP over cellular networks, we had cellular packet data. Very power and network efficient, it was the basis for things like BlackBerry's push email. Now the 2G patents are expiring, so it could be cheap and ubiquitous, built into everything. But instead the 2G networks are getting shut down...

Combining the roof with the solar panels seems like a win. A very large percentage of the cost of solar installation (50% last I checked) was labor. So when it's time to redo the roof on a house, you can also install solar panels. The interesting question is whether the panel lifecycle is the same as the roof lifecycle.

I first installed SLS Linux in 1992. It came as floppy disk images on a CD-ROM. I installed it on my girlfriend's new 386 computer, which had a monster 10MB hard disk. It booted up to the text console. I logged in, typed ls, was happy it looked like the Sun machines I had used in college. Then deleted it because she needed the space for DOS, Lotus 123, dBase IV, and WordPerfect.

I used Solaris, HP/UX, AIX, etc in my day job. I used to try to install Debian on my new computers and fail because the kernel on the installer CD was too old to support the latest chips. Finally I switched my desktop to RedHat Linux in the late 90s.

For a while, I ran Gentoo, which meant compiling everything from scratch as part of the installation process. One day for everything up to text mode, then another day to get KDE running.

The most elegant database interface I know for a low level language is the OTL: http://otl.sourceforge.net/

It is a single C++ header file, and uses streams to handle queries and results.

    #include <iostream>
    using namespace std;
    #include <stdio.h>

    #include <otlv4.h>

    otl_connect db;

    void insert() {
        otl_stream o(5, "insert into test_tab values(:f1<int>, newid())", db);
        for (int i=1; i <= 13; ++i)
            o << i;
    }

    void select() {
        otl_stream i(5, "select * from test_tab", db);
        otl_stream o(7, "insert into test_tab2 values(:f1<int>, :f2<char[37]>)", db);
        o.set_commit(0);

        int f1 = 0;
        char f2[37];

        while (!i.eof()) {
            i >> f1 >> f2;
            o << f1 << f2;
        }

        o.flush();
        db.commit();
    }

    int main() {
        otl_connect::otl_initialize();
        try{
            db.rlogon("UID=scott;PWD=tiger;DSN=mssql2008");
            otl_cursor::direct_exec(db, "drop table test_tab", otl_exception::disabled);
            otl_cursor::direct_exec(db, "create table test_tab(f1 int, f2 uniqueidentifier)");
            otl_cursor::direct_exec(db, "drop table test_tab2", otl_exception::disabled);
            otl_cursor::direct_exec(db, "create table test_tab2(f1 int, f2 uniqueidentifier)");

            insert(); // insert records into table
            select(); // select records from test_tab and insert them into test_tab2
        }
        catch (otl_exception& p) {
            cerr << p.msg << endl;
            cerr << p.stm_text << endl;
            cerr << p.sqlstate << endl;
            cerr << p.var_info << endl;
        }

        db.logoff();
        return 0;
    }

The website smells like 1996; download the examples file.

Probably Ubuntu will be bought by Microsoft.

With the cloud, especially containers, there is little future in a business that involves paying for operating systems licenses.

Most interesting is probably supporting legacy versions of operating systems for customers who value compatibility to be able to continue to run existing applications with the minimum changes.

PayPal blocked us after 10 years due to a a Kafkaesque problem, where they decided that our Hong Kong company was both a Chinese company and not a Chinese company: https://www.cogini.com/blog/paypal-know-your-customer-failur...

Amazon should pay money to the people who create the open source. Not necessarily because a license compels them to, but because it's the right thing to do. If they don't, then the ecosystem collapses.

A good example is RedHat. There is basically no money in simply selling operating system licenses anymore, but someone has to keep developing it. Amazon makes lots of money off of EC2 instances. They could easily throw a few million a year into paying kernel developers. But will they? Are they just going to be a free rider, while keeping anyone else from being able to make any money too?

Basically Amazon screwing Elastic. Take their code and monetize it, not giving anything back. When Elastic changed their license to prevent it, Amazon forks it.

It's the biggest risk to open source right now. They are following the strategy of "commoditize the complementary good". Since Amazon makes money selling machine cycles, they want the software to be free.

I assume that Nvidia and Apple are fighting about something behind the scenes.

The useful part is that each of these has a certain business model, and depends on ability to hire and/or retain people to do it.

My own company is a combination of me doing expertise consulting and the rest being experience consulting, and we don't do execution, as it's a commodity.

Running a McDonalds is different from running a fine French restaurant. The McDonalds likely makes more money, but requires a lot more scale. It's not very satisfying if you are a chef.