Vishal Krishna

There is significant unmet demand for developers who understand AI. At the same time, because most universities have not yet adapted their curricula to the new reality of programming jobs being much more productive with AI tools, there is also an uptick in unemployment of recent CS graduates. When I interview AI engineers — people skilled at building AI applications — I look for people who can: - Use AI assistance to rapidly engineer software systems - Use AI building blocks like prompting, RAG, evals, agentic workflows, and machine learning to build applications - Prototype and iterate rapidly Someone with these skills can get a massively greater amount done than someone who writes code the way we did in 2022, before the advent of Generative AI. I talk to large businesses every week that would love to hire hundreds or more people with these skills, as well as startups that have great ideas but not enough engineers to build them. As more businesses adopt AI, I expect this talent shortage only to grow! At the same time, recent CS graduates face an increased unemployment rate, though the underemployment rate — of graduates doing work that doesn’t require a degree — is still lower than for most other majors. This is why we hear simultaneously anecdotes of unemployed CS graduates and also of rising salaries for in-demand AI engineers. When programming evolved from punchcards to keyboard and terminal, employers continued to hire punchcard programmers for a while. But eventually, all developers had to switch to the new way of coding. AI engineering is similarly creating a huge wave of change. There is a stereotype of “AI Native” fresh college graduates who outperform experienced developers. There is some truth to this. Multiple times, I have hired, for full-stack software engineering, a new grad who really knows AI over an experienced developer who still works 2022-style. But the best developers I know aren’t recent graduates (no offense to the fresh grads!). They are experienced developers who have been on top of changes in AI. The most productive programmers today deeply understand computers, how to architect software, and how to make complex tradeoffs — and who additionally are familiar with cutting-edge AI tools. Sure, some skills from 2022 are becoming obsolete. For example, a lot of coding syntax that we had to memorize back then is no longer important, since we no longer need to code by hand as much. But even if, say, 30% of CS knowledge is obsolete, the remaining 70% — complemented with modern AI knowledge — is what makes really productive developers. Without understanding how computers work, you can’t just “vibe code” your way to greatness. Fundamentals are still important, and for those who additionally understand AI, job opportunities are numerous! [Original text: https://lnkd.in/gHSWcKhr ]

10,856

641 Comments

An awesome interview, as part of SIGPLAN blog with Prof Ranjit Jhala, Professor at University of California, San Diego. The topics ranged from philosophical discussions, grad school experiences, how he developed an interest in model checking and PL research and finally down to a cool demo of refinement types in Rust. Absolutely loved the demo and surely would be playing around with Flux. Some of my rough notes from the discussion : - Model checking and Floyd Hoare logic : FH logic is symbolic model checking where u r using assertions to represent sets of states and manipulating these sets of states symbolically (preconditions, post conditions etc.) - How lazy abstraction evolved from a talk that was led to thoughts on how to reuse parts of a search space that has already been explored in previous iterations. Frugality of abstractions - don’t do stuff unless u really need it .. did I hear “Laziness by default is not my cup of tea ?” - How liquid types evolved organically as a fusion of constraint solving (that type systems do), model checking and lazy abstractions. - Thoughts on type systems in Haskell and Rust - Rust type system is extremely complex yet the compiler produces so good error messages. And there is a compelling value proposition - you do the type checking and since there is no GC, your code runs very fast. - The cool demo on Flux, a language-integrated verifier for Rust that leverages liquid types, a form of dependent type system. It was also cool to see CoPilot auto-completing flux annotations ;-). First runs rust type and borrow checker and then take the type information and then do liquid types style reasoning using SMT solvers .. Talks about the challenges of implementing refinement types in an imperative language, and here is flux. - Philosophy of Verse as a unification of functional and logic programming. Has a very very sophisticated type system - we expect to hear more in the near future. - Interesting discussion on whether CoPilot like LLMs will stifle new programming language design and research (as we don’t have many examples in the wild to train on) ... and a lot more. Well worth the one and a half hours .. Link to the interview: https://lnkd.in/g-ygZxcw

10

If you are technical and trying to start something in deep tech, I would highly recommend working in the AI inference space. It is extremely tough to do efficient inference, and it is even tougher if your systems are latency-constrained. Nvidia chips don't even come close. While there are systems like Groq, Cerebras Systems, and SambaNova Systems that do a pretty good job with LLMs - there is still a lot of room for improvement in cost, availability, and efficiency. A large part of our time at smallest.ai today is spent trying to optimize our models for inference - trying to keep the latencies low across geographies as demand scales. Inference should not be so tough!

792

46 Comments

A Thought Exercise : Context Engineering with LLMs is analogous to Feature Engineering in Classical ML What are the similatieties and differences ? Share in the thread #AImusings courtesy: Jim Hong :)

28

9 Comments