What International Relations Can Teach You About Development

In 1995, I graduated from the University of California at Davis (Go Aggies!) with a Bachelor of Arts in International Relations (IR). I then proceeded, despite that "handicap", to go out and forge a career as a developer, architect, and (now) manager/CTO. During that time, I spent a lot of time in interviews and casual conversation "defending" my choice of a liberal arts degree, rather than something more traditional for the industry (a la a Computer Science degree).

Twenty years after my graduation, I can now proudly and successfully claim that my International Relations study and training made me a better programmer than those of my peers who studied Computer Science. Fortunately, these are all things that anyone--even a science major--can pick up. Pull up a chair, let's sift through history, politics, economics, social science and a little philosophy, and I'll tell you what I've learned from IR that you need to know to be a better developer.

Polytechnical Careering

If you’re a software developer, and you’re currently fluent in one language, are you doomed to irrelevancy? Is it actually better to be a ‘jack-of-all-languages, master of none’, or is there some kind of happy medium in between? And if so, how do you tell when you’re in it? In this talk, a "polytechnical" programmer will talk about his experiences living across multiple languages, platforms and storage systems. (An excerpt from the keynote of the same name.)

Iconoclasm

History is littered with the stories of iconoclasts--people who truly stood out as pioneers, lateral thinkers, and in some cases, outright heroes--and their successes and failures. From the baseball management vision of Branch Rickey to the glassblowing vision of Dale Chihuly to the engineering design vision of Steve Jobs, iconoclasts have changed our world in subtle and profound ways, sometimes loudly, sometimes quietly.

For an industry that seems so ripe and so rife with "special personalities", it would seem that programming is tied up deeply with iconoclasm. But what defines the iconoclast, what demarcates the "true" iconoclast from the mere pretender, and how can we use the characteristics of the iconoclast to change our own immediate surroundings for the better?

Busy Manager's Guide to Successful Meetings

Meetings! Clearly, if there is one topic that everyone inside of a technology organization loves to hold up as the single most responsible thing for why nothing gets done, it's the loathsome meeting. Too many long meetings, too many people in meetings, too many boring meetings, too many... meetings.

And yet? They're a necessary and critical part of getting our job done, as evidenced by the fact that whenever we get stuck, we call a meeting. We walk over to a coworker's desk, we put a message into Slack, we send an email... we do dozens of things that are all meetings--but without the PowerPoint.

What if the problem isn't the meeting, but the way we understand and practice them?

In this talk, we'll go over meetings--the good, the bad, the ugly--and talk about how you, as a leader of your team and in your company, can make sure your meetings don't suck.

Busy Manager's Guide to Performance Management

It is said that the performance of a manager (team lead, tech lead, leader, etc) is the same as the performance of their team. If that's the case, and you lead a team of developers, then suddenly your bonus--and promotions--are in the hands of a group of people whose actions you don't directly control. Is it any wonder why micromanagement on software teams is so rampant?

In this presentation, we'll talk about the tools by which a team lead/software development manager can not only get the best out of the team. And what to do when they don't meet the necessary expectations. And help the team grow and get stronger to boot. And more.

Busy Manager's Guide to Interviewing

For most developers and their managers, interviewing candidates to join the team is a process frought with uncertainty, deep feelings of imposter syndrome, outright feelings of competition, not to mention all those HR regulations. Coupled with the constant reminders about the costs of a "bad hire", interviewing becomes one of the most stressful periods of the engineering manager's professional life. Building great teams start with hiring great people, so pressure's on!

In this session, we'll take an analytical view of what the interview process is actually intended to do (hint: it's not just to prove a candidate's skills!), go through an example of how to structure an interview process, and provide some important structure around interviewing that managers can carry with them into their next interview cycle.

Busy Java Developer's Guide to Java Bytecode

Ever wondered what all these different Java languages compile down to? What makes them interoperable with one another? What drives the "Write Once, Run Anywhere" nature of the JVM? Come to this session and find out what JVM bytecode looks like, and how (ridiculously simple) it is to learn.

Busy Developer's Workshop on Flutter

Ever wanted to build mobile apps using just one codebase, preferably one that utilizes the same skills that are already in use across the Web? Using Flutter, that's entirely an option. In this full-day workshop, we'll go over how Flutter works, get a primer on the Dart language (the language that Flutter uses to build applications), how to build a simple application using it, and then deploy it to Android or iOS devices, depending on what we have in the room (and who's willing to risk their mobile device enough to install a foreign app on it!).

Busy Developer's Guide to Nim

Nim is a statically typed compiled systems programming language. It combines successful concepts from mature languages like Python, Ada and Modula, and supports a large number of interesting features that put it on par with C++ or Rust as a systems-level programming language. In this presentation, we'll be taking a look at how to get started, and just enough syntax and semantics to begin your Nim journey.

Busy Developer's Guide to Esoteric Programming Languages

Ever wanted to spend twenty minutes learning about languages that you'd never, ever, EVER want to use for any practical purpose?

Busy Developer's Guide to Building Languages

Ever wanted to truly explore what it would be like to be a James Gosling, or a Bjarne Stroustrup, or Anders Hejlsberg? Want to see what it's really like, building a language from soup to nuts? This presentation will take you through that process exactly, from deciding whether your language will be compiled or interpreted, or static- or dynamically-typed, through defining a simple grammar, building the parser, constructing the AST, and generating code out the back end. We'll look at tools that can simplify this process, and discover that building a custom language for a particular task isn't quite as hard as it might seem at first. It's domain-specific languages, without the PhD.

Busy Developer's Guide to Ballerina

Despite the frivolity implies by its name, Ballerina, like the dancers who bear the same name, is a graceful language with surprising elegance and strength inside a slender frame. Still (as of this writing) a self-described "work in progress", Ballerina is a language designed from the ground up for the world of Web 2.0, with built-in support for HTTP endpoints, JSON data types, and an input format--either textual or graphical--that makes it perfect for building platform clients and implementations.

In this session, we will go over the Ballerina language and environment, and explore what a language "built for the Web" looks like.

Busy Architect's Guide to Platform-Oriented Architecture

In the 90's, developers sought to build web pages. In the 2000's, it was all about web applications. But clearly the needle is still moving, and the technology keeps evolving. "Platform-Oriented Architecture" (or POA) is, very simply, what the next wave of software development is moving towards. In this workshop, we'll go over why that is, including what forces are driving us down this direction, and then spend time building out a simple platform, creating a model and a template for the kinds of POA projects that are to come.

Busy Architect's Guide to the Fallacies of Distributed Systems

Every software developer, at some point in their career, has fallen into the trap of 10 devilishly subtle distributed system assumptions. Come hear what they are, why they all lead to big trouble and painful learning experiences in the long run, and how to avoid them using the tools and technologies of your favorite platform.

Busy Developer's Workshop on Building a Virtual Machine

Ever wanted to understand how a virtual machine--like the Java VM, .NET CLR, or V8 Javascript engine--actually works, but were too afraid to ask? One of the best ways to get that knowledge is to sit down and build one, from scratch. In this workshop, we'll do exactly that: starting from "File|New", we'll build a working interpreter for a relatively simplistic virtual machine, and along the way, learn a great deal about how VMs work in general. But be warned! Learning this material could have the unexpected side effects, like great appreciation for other virtual machines and the start of a lifelong obsession.

Busy Developer's Guide to Next-Generation Languages

Remember when TypeScript, or C#, or even C++ was new, and you wished you'd known they were going to "be big" so you could be the person ahead of the curve instead of struggling to catch up to where everybody else seemed to be already? The world-famous hockey player Wayne Gretzky, when asked what made him different than all the other players, famously said, "I didn't skate to where the puck was--I skated to where the puck would be." In this presentation, we're going to take a look at a few languages that incorporate concepts that might--with heavy emphasis on the word "might" in that sentence--be where the puck will figuratively end up. These languages may not be what you end up using in your day job in 2025, but they could be exposing and refining the concepts that define the language that will.

Busy .NET Developer's Guide to Orleans

Within the distributed systems community, much has been made about the "actors model" and its implications for building large-scale, fault-tolerant, highly resilient code bases. The Orleans project, from Microsoft, is the latest entry in the genre, and it represents quite a different take than the traditional WCF- or REST-based discussion. In this presentation, we'll go over what an actors model is, how Orleans implements it, and how Orleans takes a different approach on the whole subject.

Busy Developers Guide to Writing (Prose)

To many developers, the job is about writing code. Then, as they grow more senior in their careers, they discover--sometimes painfully, sometimes too late--that the job actually shifts to entail far more of the writing of prose. That is to say, "writing". Putting one word after another in a structured form such that it clearly and unquivocally carries meaning across to its readers. In this presentation, we are going to examine the craft of communicating via prose. Because, like it or not, your career demands and depends on it. And, you'll quickly discover, writing code becomes much, much easier when you know how to write prose (and vice versa).

For an intermediate developer audience in any technology stack

Other Presentations Available

Visit https://www.newardassociates.com/presentations/ for the complete list

Many talks can be combined in various ways to form all-new talks; just reach out and ask!

Busy Developer's Hands-On Labs -- Angular

In this all-day workshop, we'll start from zero--including no prior familiarity with TypeScript--and work all the way up through a working Angular application that makes use of the core Angular features: components, services, HTTP, and more.

Busy Developer's Guide to Assembly Language

"Saaaaaaaay whaaaaat? Assembly language? Seriously?" A developer should always know one level below the level at which he/she works, and for many developers, assembly is that level. Come on out and learn a little about how assembly language works, not so that you can write anything major in it, but so that you can read application crashes "in the raw" and be able to walk through code even if you don't have the source.

Busy Developer's Guide to Flutter

Flutter is a new cross-mobile framework and platform (using a custom language, Dart, that started out as a Javascript-transpiling target before it was adopted by Flutter) from Google that looks to solve some of the classic problems--such as state management and component reuse--that the native mobile languages/platforms don't really solve. In this session, we'll take a pass through Dart, see how Flutter works, and discuss where this fits in the world next to Xamarin, Javascript-based toolkits like Cordova, and native Swift/iOS or Kotlin/Android.

Busy .NET Developer's Guide to Python

Python is a general-purpose programming language and platform that provides a rich ecosystem of powerful features and libraries. As a dynamically-typed object-oriented language using "significant whitespace" to denote scope blocks (instead of lexical markers), Python is relatively easy for the .NET developer to pick up, and Python's success in the world of "data science" makes it a great "second language" for any .NET developer.

Busy Developer's Guide to Naked Objects

"I invented the term 'object-oriented', and I can tell you for a fact that C++ was not what I had in mind." --Alan Kay, inventor of Smalltalk (among other things)

But what, exactly, did Mr. Kay have in mind? If not the kind of object-oriented that C++ (and later Java and C#) developers became accustomed to, then what did he really imagine O-O development would be like? In this presentation, we'll examine a concept more recently popularized as "naked objects"--the idea that objects should not be used to present a user interface, but that the user interface should be based around the domain objects themselves. We'll look at the Naked Objects libraries, how they work, and what development using NakedObjects looks and feels like. Careful, though: once you start working with this stuff, you may never want to go back to "traditional" means of writing code ever again.

Managers are from Mars, Developers are from Venus

You're a manager. You've been hired to run a small (or large) development team, and for the life of you, you can't understand these people. Every time you try to motivate them, they balk and resist. You try to hire them, you can't figure out what they want and they walk away. Then, without any sort of action on your part, suddenly they put in 16-hour days, and they pull off some amazing work, but when you try to ask them to do it again for a critical update, they get angry and quit. What the heck? Where did these bizarre alien creatures come from, and how in the world are you supposed to work with them?
You're a developer. You work for what has to be the most clueless manager in history. For the life of you, you can't understand this guy. He keeps trying to "motivate" you when all you want is for him to get out of the way. He's ready to drop thousands (or millions) of dollars on a release party, but getting him to pony up some cash for a conference or training class is like wringing blood from a rock. What the heck? Where did this bizarre alien creature come from, and how in the world are you supposed to work with him?

Busy Developer's Guide to Expert Systems

In the world of AI, the expert system is one of the oldest--and richest--topics of discussion. Not entirely a system of "machine learning", the expert system still represents a powerful tool for giving users the "right" answer when the solution is a complex sequence of forward- and back-tracking permutations, such as determining the best wine to choose with dinner, how to win the classic river-crossing puzzles, or schedule employees in the face of their various constraints and time-off requests. In this session, we'll talk about what an expert system is, what a RETE engine is, and how they can be used in a mainstream environment like .NET.

Busy Developer's Guide to Ballerina

Despite the frivolity implies by its name, Ballerina, like the dancers who bear the same name, is a graceful language with surprising elegance and strength inside a slender frame. Still (as of this writing) a self-described "work in progress", Ballerina is a language designed from the ground up for the world of Web 2.0, with built-in support for HTTP endpoints, JSON data types, and an input format--either textual or graphical--that makes it perfect for building platform clients and implementations. In this session, we will go over the Ballerina language and environment, and explore what a language "built for the Web" looks like.

Busy Developer's Guide to the Clouds

Microsoft has one, Amazon has one, but it turns out that there's a lot of different developer-focused cloud environments out there, and sometimes it's exactly what you need to get your project going quickly--assuming you know it exists. In this session, we're going to take a survey of a variety of different cloud providers, many with wildly varying different approaches to "what developers need", and give you a series of ideas to explore the next time the boss says, "We need to move into the cloud!"

Busy Developer's Guide to Kotlin

With the release of Kotlin, JetBrains makes its first serious dive into the programming language space, and by all accounts, it's quite a graceful dive. Kotlin integrates much of the object-oriented thinking over the last thirty years together with several new ideas from the world of functional programming to create a language that is much of the best of both worlds, without the ceremony and legacy that bedevils them. No language is perfect, and Kotlin certainly has its quirks, but in this session we will go over Kotlin's syntax and semantics, and who knows? Maybe this becomes your next language of choice.

Architectural Katas Workshop

Fred Brooks said, "How do we get great designers? Great designers design, of course." So how do we get great architects? Great architects architect. But architecting a software system is a rare opportunity for the non-architect. The kata is an ancient tradition, born of the martial arts, designed to give the student the opportunity to practice more than basics in a semi-realistic way. The coding kata, created by Dave Thomas, is an opportunity for the developer to try a language or tool to solve a problem slightly more complex than "Hello world". The architectural kata, like the coding kata, is an opportunity for the student-architect to practice architecting a software system. In this session, attendees will be split into small groups and given a "real world" business problem (the kata). Attendees will be expected to formulate an architectural vision for the project, asking questions (of the instructor) as necessary to better understand the requirements, then defend questions (posed by both the instructor and their fellow attendees) about their choice in technology and approach, and then evaluate others' efforts in a similar fashion. No equipment is necessary to participate--the great architect has no need of tools, just their mind and the customers' participation and feedback.

Busy Developer's Guide to NoSQL

With the introduction of CouchDB to the world, the world suddenly seemed to be alive with a whole slew of "alternative" approaches to data persistence, collectively called "NoSQL" and offering a "slightly different" to "radically different" view of data storage and retrieval. It’s left a few developers scratching their heads, trying to figure out when to use a NoSQL database instead of a regular database, much less which NoSQL database to use. In this session, we’ll examine the NoSQL ecosystem, look at the major players, how the compare and contrast, and what sort of architectural implications they have for software systems in general.

Busy Developer's Guide to Polytechnical Careering

Starting with the ‘domain-specific language’ movement, and bolstered by the Pragmatic Programmers’ suggestion that programmers should learn a new language every year, the notion of ‘polyglot programming’ became something of a critics’ darling when talking about career paths. But somewhere along the way, it feels like the original intent has been lost, and the focus has shifted to ‘learn to program in as many languages as possible’. If you’re a software developer, and you’re currently fluent in one language, are you doomed to irrelevancy? Is it actually better to be a ‘jack-of-all-languages, master of none’, or is there some kind of happy medium in between? And if so, how do you tell when you’re in it? In this talk, a polyglot, polycrepido and polypraeclusio programmer will talk about his experiences living across multiple languages, platforms and storage systems. It’s not all been a bed of roses, you’ll find, but there are advantages, up to a point. More to the point, by the end of the conversation, you’ll have a better idea of where you want to fit on the ‘polytechnical’ continuum, and how to make the necessary steps to get there.

PsyPhilProg: Eudaimonia

PsyPhilProg: The intersection of psychology, philosophy, and programming, and what we can learn from it.

The ancient Greeks had a term, "eudaimonia", which, translated loosely, means "the good life". It is this concept of which Socrates spoke when he said that "the unexamined life was not worth living"; it is this same concept of which the Stoics spoke when the Roman Emperor Marcus Aurelius wrote his "Meditations".

Having a clear definition for what defines "the good life" is what brings many people a sense of fulfillment, accomplishment, and joy. So why is it so hard to find? And why is it that so many people in the software industry--and industry which, by all rights and measures, is one of the most successful on the planet--feel so far removed from it, whatever it is?

The Role of an Architect

What is the role of an architect in a software project? This question has plagued many a software organization (and even those who do the job), and provided loads of entertainment. In this presentation, we aim to explore the intersection of software architect with the worlds of architecture, psychology, business, and even music. By the end, though, you'll have a clear idea of what an architect is, does, and needs.

Busy Developer's Guide to LoopbackJS

In the world of the NodeJS-based server, finding a framework that can handle the heavy lifting of some common chores can mean the difference between getting a project done and getting a project mired in a myriad of low-level details. LoopbackJS, a NodeJS framework supported by IBM and written by some of the originators of NodeJS, is a framework designed to handle much of the common server-side requirements, including persistence, authentication/authorization, and business logic. In this session, we'll take a tour through Loopback, see how it works, and cover some of its major salient points so that you can see if this is something worth spending time in.

A Grizzled Veteran's Open Q-and-A

Are you new to the software development? Do you wish you had the opportunity to ask somebody who's been in the industry for almost 30 years any question that might come to mind, whether about languages/platforms/tools or about how to make your own mark? In this session, an international speaker/author/technologist will walk in, sit down for an hour, and answer any question you have as honestly as he can.

Busy .NET Developers Guide to Multiparadigmatic Design

C++ was widely denigrated as a "hopelessly complex" language with "way too many moving parts", and in truth, it was a language made up of three dominant paradigms: procedural, object-oriented, and meta-programmatic. C#, by contrast, has five dominant paradigms: procedural, object-oriented, meta-programmatic, functional and now dynamic. (Visual Basic doesn't fare much better on this score.) If we're to use these new multi-paradigm languages successfully, we'd better have a good idea of what the paradigms are, what a language paradigm is, and what the different paradigms are in the languages we know and love.

Busy Developer's Guide to Chrome Development

When Google introduced Chrome, the world pretty much took it on faith that it would look to adhere to the Web standards: HTML, JavaScript, CSS, and others. And when Google sought to give developers opportunities to extend the browser using browser-specific extension points, it was nothing more subversive than what Microsoft, Firefox, Netscape or Apple had done before. But Google chose to use the same tools--HTML, JavaScript, CSS, and others--to provide those extensions, and in some ways, avoided some of the pain points that previous native-code-based browser extensions ran into. In this talk, we're going to examine the tools and APIs that a developer can use to build a Chrome extension--and when they can be useful, and when they just annoy people.