Kito Mann
Principal Consultant, Virtua, Inc.
Richmond, Virginia, United States
Actions
Kito D. Mann is the Principal Consultant at Virtua, Inc., specializing in enterprise application architecture, training, development, and mentoring with microservices, cloud, Web Components, Angular, and Jakarta/Java EE technologies. He is also the co-host of The Stackd Podcast and the author of JavaServer Faces in Action. Mann has participated in several Java Community Process expert groups (including CDI, JSF, and Portlets) and is an internationally recognized speaker. He is also a Java Champion and Google Developer Expert in Web Technologies. He holds a BA in Computer Science from Johns Hopkins University.
Area of Expertise
Topics
Let’s Make Hello Kitty Talk!
This session explains what computers, apps, and software are (including less common computers like cars and IoT devices like Alexa devices) and then quickly jumps into building a simple game using HTMl5 Canvas, Web Components, JavaScript and Web Platform APIs to make Hello Kitty, Minions, Paw Patrol and other characters talk and move around on the screen. Students participate in different roles of software development in order to to help build the application, and choose the background, characters, and what they say. Come see how we can make Hello Kitty and other characters talk!
Micro Frontends: Breaking up the Frontend Monolith
Over the past several years we have embraced microservices as a way to “break up the monolith” and reduce complexity, allowing teams to focus on specific areas of functionality, while providing more flexible scaling and better fault isolation. However, for most of us, the front-end has remained largely un-touched — it is, in essence, still a monolith. What if the same team was responsible for the UI and the service, an you could compose a web app out of different micro frontends — each providing a core set a functionality but all playing well with each other? This tutorial explains how that process can work, using Web Components as the bridge between different JavaScript frameworks on the front end, and Eclipse MicroProfile for the Java microservice on the back-end.
Getting Things Done for Programmers
If you talk to the most well-known developers, whether they’re people within your organization or internationally recognized experts, you’ll find something in common: they’re productive. Usually, it isn’t just dumb luck. More often than not, they’ve focused on becoming more productive.
There are dozens of methodologies that claim to increase productivity, but there’s a clear winner amongst highly productive software developers: Getting Things Done (GTD). GTD, originally described in productivity guru David Allen’s best seller of the same title, describes a set of behaviors which, when followed regularly, reduce stress and help you become more productive at the same time.
This session looks at how programmers, architects, and technical managers can apply GTD principles to improve the productivity of individuals and the group as a whole. In addition to discussing the core principles of GTD, this session also examines tools which can be used to implement the methodology, as well as similarities to agile software development practices.
GraphQL Distilled
REST is all about endpoints that perform specific queries or operations. This works fine, but the client is limited by which queries have been exposed. What if the back-end exposed the data, but the client could decide which subset of data it needed, or how to interact with that data? That’s the promise of GraphQL — simplify the back-end, give the client more power, and make it easier to evolve APIs. In this talk, we’ll explain what GraphQL is, how it works, and look at a JavaScript client and a Java back-end.
Future-proof your Web Apps with Web Components and LitElement
Building a web app? Should you pick Angular, React, Vue, or the something else? Did you know that browsers have a built-in standard for building reusable components, called Web Components? With a little bit of help from LitElement and LitHtml — libraries from Google’s Polymer team — you can build powerful web apps that run natively in all modern browsers (and can even work in IE). This means faster performance, less overhead, and most importantly, long-term compatibility (once it’s in the browser, it stays in the browser). This session dives into LitElement and LitHtml, and explains how how you can build components and entire applications using property binding, templating, and other common framework features in a simple, performant, and standards-based manner.
Foundations of Modern Java Server Apps
Java has a long history of running on the server. From the early days of servlets, to JSP, Java web frameworks, Java EE, and Spring, to today’s hip microservice frameworks, the platform has been a strong, solid player, relied upon by thousands of companies, governments, and organizations. But what do these microservice frameworks like Dropwizard, Spring Boot, and Eclipse MicroProfile have in common with the older days of Java? It turns out, there’s quite a lot of foundational tech that made the newer frameworks possible. In this talk, we’ll take a look at different parts of the foundation that you may not even realize you’re using, for everything like handling REST requests, processing JSON, using Web Sockets, talking to a database, performing validation, and more. We’ll also look at how these standards evolve within the Eclipse Jakarta EE, and what’s in store for the future.
Effective TypeScript
JavaScript is in every browser. It’s flexible, dynamically, very dynamic, and somewhat flawed. Because of its shortcomings, there are countless languages that transpile to JavaScript. One of the most popular of these is TypeScript, which provides type-safety and other features like generics, as well as early implementations of new JavaScript features. TypeScript has become even more popular with the newer versions of Angular. However, developers often don’t take full advantage of the language, instead reverting to pure JavaScript when there’s a much better (and strongly typed) TypeScript alternative. In this session, we’ll take look at common features developers don’t use, and show you how to get the best out of this awesome language.
Avoiding ReWork - Strategies for finishing what we started on time
While developing new products or large features, the last 10% of effort is as hard as the first 90%. We’ve all been in scenarios where a feature seems to take forever to finish and release after the basic functionality is “done”. Even when it is finally rolled out, we often have to ReWork the feature either because it is missing functionality, or it has so much tech debt that enhancements aren’t possible without ReWork. In this session, you’ll learn concrete techniques to prevent ReWork. These techniques include feature analysis, managing tech debt, splitting the work into small milestones, and others. You’ll be able to use these tried and tested techniques to transform the deliveries of your teams, improving productivity and morale.
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top