SDLC
Turning source into reliably delivered, integrated, and secured software — from C/C++ and enterprise Java to today’s Python and AI/GPU model stack.
This is the build-and-deliver axis: anything software. Training a model counts too, because it still ships a deliverable. The domain spans more than thirty years, and its oldest skills — systems languages and middleware from the mid-nineties — are still part of it, because the build-and-deliver fundamentals do not age out. Centralized CVS and ClearCase matured into Git and CI/CD; enterprise Java gave way to the Python and AI stack. The tools rotate; the discipline does not. As with the other domains, what follows leads with the newest work.
Convergence
Software development has been reshaped by the convergence of general programming with AI and GPU-accelerated computing. The Hugging Face ecosystem anchors it — the Hub, Transformers, and Datasets as the de-facto substrate for building and fine-tuning models — alongside GPU-native training frameworks such as NVIDIA NeMo.
The everyday craft is Python-centric and notebook-driven: Jupyter over pandas, and its GPU-accelerated cousin cuDF. Running in parallel is a reinforcement-learning stack — OpenAI Gym, Stable-Baselines3, PPO and SAC over the MDP formalism — whose PPO bridges directly into RLHF for language-model fine-tuning. Data engineering, deep learning, and sequential decision-making have fused into one GPU-accelerated, model-centric practice.
Transition to AI
DPUs and the DOCA framework marked the leading edge, extending the CUDA programming model to NVIDIA BlueField so that networking, storage, and security offloads could be programmed like accelerators.
Model-building consolidated around PyTorch’s define-by-run style and TensorFlow/Keras, both on GPU-accelerated autograd. Architectures split by data shape: CNNs for vision, RNNs and LSTMs for sequences, GANs for generative synthesis. Reinforcement learning began surfacing as the RLHF ingredient for aligning language models — even as transformers were already displacing the recurrent workhorses for NLP.
Cloud-native operations
The workhorse languages bifurcated by layer. Python became the de-facto general-purpose tool for back-end services, scripting, automation, and the rising data-science and ML work. Go became the language the cloud-native substrate itself was written in — dependency-light static binaries and goroutine concurrency powering Kubernetes, Docker, and their operators. Delivery was organized around Scrum’s fixed-length sprints.
Distributed systems
Building for scale defined the era. Web functionality was exposed as REST APIs over HTTP and JSON, secured through delegated-auth standards (OAuth 2.0, OpenID Connect), and engineered for horizontal scaling, load balancing, sharding, and caching — with security increasingly integrated into the delivery pipeline rather than bolted on after it.
Datasets outgrew the single machine, pushing work onto distributed big-data platforms such as Hadoop and Spark. All of it shipped under a de-facto Agile cadence with CI automation via Jenkins. The enterprise-Java and integration furniture of the day — Spring, Maven, rules engines, messaging middleware — framed the era but has since cooled into legacy context.
Network modeling
Development centred on the Java enterprise stack: multi-tier server-side systems on J2EE and Java EE in application servers such as JBoss, with EJB carrying transactional logic and Hibernate mapping objects to relational tables.
System integration ran on XML and heavyweight, WSDL-contracted SOAP web services. That discipline seeded the durable habits of deliberate API design that are still relevant. On the front end, the browser was pushed toward desktop-grade rich UI through JSF, Flash/ActionScript, and applets, while AJAX quietly began updating pages without a full reload — the technique that later underwrote single-page apps. Most of these specifics are now obsolete, but they mark the enterprise-Java and XML-web-services world this era’s software was written in.
Control loop
The roots. Compiled systems languages — C and C++ for performance-critical and embedded work, with Java arriving as portable VM-hosted enterprise plumbing — talking to relational data through SQL and desktop tools such as Microsoft Access and Visual Basic.
Distributed systems were wired together by CORBA and its IDL contracts, while carrier-grade network management leaned on the OSI/TMN stack: ASN.1, GDMO, and the XOM/XMP C APIs driving CMIP and CMIS over Q3. Source and builds were governed by centralized configuration management (CVS, enterprise ClearCase) under formal release discipline — the roots that the Git, web, and CI/CD-pipeline world would later mature into.
The software lifecycle delivers onto infrastructure, hands what it builds to operations, and is where agentic transformation has inverted the oldest discipline in this domain: version control, CI/CD, and code review are now the deterministic guardrail around non-deterministic, agent-authored code.