We'll be meeting at the Magenic office every 2nd Thursday of the "odd" months (January, March, May, July, September, and November) unless otherwise noted in the session details. We'll start at 5:30 PM with food and drinks, and the presentation will go from 5:45 to around 7 (go to the Location page for directions).
At each event, we'll have dinner (either pizza or sandwiches) and some free giveaways. If you want to attend the next meeting, please register by sending an e-mail to jasonb@magenic.com. This will ensure we get an accurate head count (the room can hold up to 30 people comfortably).
There's also a Facebook group that you can join - go here for the details. You can follow the official Twitter account for the user group by clicking here.
Clojure is a relatively new dialect of Lisp which runs on the JVM as well as the CLR. Perhaps the most powerful feature of Lisp is its ability to define macros to create syntactic abstractions. In this presentation, Kurt Christensen will explain what macros are and why you might want to create them, along with some tips and tricks for writing and debugging Clojure macros.
Since 1995, Kurt Christensen has been paid to program computers using Pascal, C, x86 assembly language, C++, SQL, Java, VB.NET, Javascript, C#, Clojure and Ruby. Amazingly, a small portion of this code actually worked and made it into production. Kurt has also spent the last 9 years working as an "agile coach", whatever that means.
The web runs on CSS and JavaScript, but JavaScript can be clunky, and CSS is a mess. Sass and CoffeeScript take these technologies and crank them up. In this talk, you'll learn how to use CoffeeScript to build JavaScript applications using a concise but powerful syntax. And you'll learn how to make your CSS much easier to maintain using powerful Sass features like variables, functions, and iteration. Then we'll discuss how to build these into your workflow so you can take advantage of them right now.
Brian P. Hogan is an author, editor, trainer, and web developer who's been building web sites professionally since 1995 as a freelancer and consultant. He enjoys teaching and writing about technology, particularly web design, accessibility, and development. When not hacking on Ruby or JavaScript code, he's writing songs, watching "The Simpsons," or spending quality time with his wife and daughters.
Javascript has been one of the most hated languages of modern times, but the emergence of ajax has forced people to *gasp* actually learn the language. I'll talk about the history of javascript from it's origins to the present and review the parts of javascript that have allowed many developers to call a truce in the javascript hate war and use it for serious web development. We'll focus on prototypical inheritance and javascript's features derived from functional programming models. At the end, we will look at one terrible peice of code and transform it into something much better.
Walker Wilkins is an independent contractor currently working on ASP.NET and Ruby on Rails projects. Before coming to Minnesota, he rangled documentation at a small banking software company as a Technical Writier. While teaching himself to program he had plenty of help from a misplaced, forward-thinking programming manager and a number of books.
MetaSharp is a pattern matching library for the .NET runtime. It provides a fluent interface for pattern matching as well as languages for creating complex internal and external DSLs. In this session Justin will cover MetaSharp in detail.
Justin Chase works for Microsoft Expression in St. Paul, MN.
Looking at sites like http://langpop.com/ it becomes apparent that C/C++ is still in heavy use. We will take a look at some of my favorite things about programming in C/C++ and also look at some new stuff for C++ forth coming in C++0x. Maybe the new languages are sexier and more fun, but C/C++ is like a nice set of worn in slippers: not fancy but it does the job.
Richard Moore is a Staff Scientist at 3M Company working in the corporate research Software, Electronics, and Mechanical Systems Laboratory (SEMS). Richard has a Master's of Science in Electrical Engineering from the University of Nevada Reno. His work experience over the last 32 years ranges from microprocessor design to leading teams in the development of commercial software applications and systems. Areas of specialty and interest include image processing, graphics, printing, color, parallel algorithm development, and high speed computing architectures among many others.
F# is a relatively new language from Microsoft, which enables idiomatic programming in functional, imperative and object-oriented paradigms. With the release of Visual Studio 2010, is now officially supported by Microsoft along side VB.NET and C#. This talk will focus on functional programming in F# as well as units of measure, computation expressions and metaprogramming with quotations.
Jacob is a senior developer at Atomic Playpen in Minneapolis. Over the past seven years, he has worked with a wide variety of technologies and programming languages. Jacob became a father in October when he and his wife Betsy welcomed their daughter Lucy into the world.
Using a component based adaptive neural architecture; a process for developing a scripting language in managed code will be presented. The scripting language will be a strategy/configuration hybrid implementation with a mixed hard and soft architectural approach used in a video game AI engine. The Fuzzy Adaptive Neural Scripting (FANS) approach has been in development for the last three years and is nearing completion. The result is a meta-language which uses SQL for documentation, XML as code with the AI engine as the interpreter. The FANS AI engine uses input from the user, physics, planning, and graphics engines with the desired goal of entertaining and fooling the user into believing they are playing against a real person.
Larry Louisiana has worked in academic research for 9 years, and after getting bored with photo-physical chemistry, has been developing in C and C#. He is an author on a pending software process patent, and has been spending his free time playing with XNA.
NOTE: This event is a joint venture with the CocoaHeads group. It will take place at the Thomson-Reuters building in Eagan - click here for directions. Meet in the lobby by 6 PM - you will need a photo ID and sign in to get into the building.
This presentation is all about the Lua language, some of the reasoning behind its choices, what the syntax looks like, and the capabilities it provides. We'll also see a little bit about what it looks like from the standpoint of a C program to talk to a Lua API if one is embedding a Lua runtime. Finally, we'll talk about the Corona environment by Ansca Mobile for building iOS and Android applications in Lua, demonstrating a little bit of code written against the Corona Game Edition.
Troy Gaul was the lead engineer on Adobe Lightroom, which used Lua for most of its application-level code. He's now doing independent iOS development in Objective-C mostly with a few apps nearly ready to be submitted to the app store.
Axum is a programming language launched as an incubation project within Microsoft DevLabs. Unlike traditional object-oriented languages, Axum is an actor-oriented language that uses principles of isolation, actors, and message-passing to increase application safety, responsiveness, scalability, and developer productivity. This presentation will include a walkthrough of small sample applications written in Axum for Visual Studio 2010 that offers an overview of the Axum language.
Jeff Ferguson is a Principal Consultant with Magenic. He has been with Magenic since 1996 and has worked in the software development community since 1989. Jeff has developed code for the Microsoft technology stack during all of that time and has been involved in a variety of both desktop and Web-based projects using C, C++, C# and Visual Basic. Visit his blog at http://www.geekswithblogs.net/JeffFerguson/.
Internal DSLs hide the accidental complexity of a problem behind a natural, English-like API. For some programming languages this means learning a complex and underpowered reflection API, with plenty of syntactical noise left around from the host language. External DSLs overcome these limitations, but require more knowledge and time than most of us have. Internal DSLs in Ruby are built upon a generalization of the object oriented thinking we already know and like. It's not long after getting started with Ruby that you can begin to create your own mini-languages, which makes Ruby a lot of fun. In this talk I'll try and distill the down the properties that make Ruby great for "metaprogramming", going through code from popular libraries like Ruby on Rails, Sinatra, and RSpec. I'll show how you don't need to wait for your language's next major release to get features like a 'using' block or generated getters/setters - just build them yourself!
Mike Frawley has been programming in the healthcare and financial industries professionally for several years, using technologies like C#, Ruby on Rails, and CouchDB. He loves Ruby, but thinks 100% JavaScript applications are not far off.
No matter what language runs on the CLR, it all comes down to IL. In this session, I'll cover what opcodes and metadata are, what's possible at the IL level that most languages don't expose, and how you can use this knowledge to spelunk the contents of an assembly (and modify them too!).
Jason Bock is a Principal Consultant for Magenic, and is also a Microsoft MVP. He has worked on a number of business applications using a diverse set of substrates and languages such as C#, .NET, and Java. He is the author of "Applied .NET Attributes", "CIL Programming: Under the Hood of .NET", ".NET Security", and "Visual Basic 6 Win32 API Tutorial". He has written numerous articles on software development issues and has presented at a number of conferences and user groups. He also run the Twin Cities Code Camp and the Twin Cities Languages User Group. Jason holds a Master's degree in Electrical Engineering from Marquette University. Visit his web site at http://www.jasonbock.net.
If you would like to produce software that is reliable and easy to maintain, then programming with Microsoft Code Contracts may be for you. It is available now for Visual Studio 2008, and Visual Studio 2010 Beta2. Code Contracts are the realization of years of work among the Spec# team at Microsoft Research DevLabs.
This presentation will provide motivation (Why use this?), explanation (What is this?), and guidance (How do I use this?)
You will see plenty of code examples. We will go beyond merely cataloging features and benefits. You will observe the rythm of development as I make decisions to add contracts (or not) to a sample application. And you will also see me use the helpful but imperfect static checker to identify opportunities for improving my code. Along the way, we will pause to address questions that come to your mind as you watch the process of adding contracts to realistic product code.
David Kreth Allen is currently a software developer for the ELCA Board of Pensions in Minneapolis Minnesota. He has always been interested in ways to improve code quality. He fell in love with contract programming techniques when he first learned to program in the Eiffel programming language, under the instruction of Dr. Bertrand Meyer. He later used home-grown contract programming techniques with JavaScript and C# while he waited for these techniques to mature within the Microsoft technology stack.
Clojure is a dialect of Lisp which runs on the Java Virtual Machine and is designed for easy integration with existing Java code, and also provides features like software transactional memory, lazily-evaluated sequences, and more. In this presentation, I will provide a brief introduction to what Clojure is, and how it can be used.
Kurt Christensen has been getting paid to write code for 15 years, using a variety of different programming languages. For the last 7 years he's also been "coaching agile teams" (whatever the hell that means).
MetaSharp is a developer tool designed to assist in the creation of programming languages. Using MetaSharp's fully extensible, pipelined transformation engine you can easily create your own domain specific languages or general purpose programming languages.
Justin Chase is a software developer from St. Paul MN and works for Microsoft on the Expression team. In addition to loving WPF and Xaml and Expression Studio he has special interests in domain specific languages and games.
Microsoft code-name "Oslo" includes the ability to define your own domain specific language (DSL), a metadata repository hosted in SQL Server and a graphical tool ("Quadrant") to edit that metadata. One part of the Oslo vision is that you might define a DSL, build code in your language, compile that code into the repository and then create a runtime to dynamically execute that metadata. Taking this vision and combining it with the popular CSLA .NET framework, the result is MCsla. This is a prototype DSL grammar, repository schema and runtime that dynamically creates and executes CSLA .NET business objects with a WPF UI. The result is a fully functional application that you can create with a fraction of the code you'd need to write with traditional programming techniques. Learn how MCsla was created and how it works in this rapid-fire walk through the depths of the Olso technology.
Rockford Lhotka is the creator of the popular CSLA .NET development framework, and is the author of numerous books, including Expert C# 2008 Business Objects and Expert VB 2008 Business Objects. He is a Microsoft Regional Director, MVP and INETA speaker. He contributes to several major magazines and regularly presents at major conferences around the world. Rockford is the Principal Technology Evangelist for Magenic (www.magenic.com), a company focused on delivering business value through applied technology and one of the nation's premiere Microsoft Gold Certified Partners. For more information go to www.lhotka.net.
NOTE! Twin Cities Pragmatic Beer is meeting after our event - visit the site for more details.
For over 14 years CFML has been facilitating Rapid Application Development through Adobe (previously Macromedia/Allaire) ColdFusion. CFML, the language that ColdFusion uses, is an easy-to-learn, powerful, web application development scripting language that receives high praise from those that use it. But until recently, CFML has been used by only a small subset of web application developers. This is changing, and fast!
Recently, two new, Free and Open Source CFML engines have been made available. Both are fast, powerful, and production-ready, giving everyone the opportunity to take a fresh look at CFML as a development tool for building web applications. Additionally, one of the biggest new releases of ColdFusion will be coming from Adobe soon. ColdFusion 9 features integration with amazing open source projects like Apache Lucene/Solr and JBoss Hibernate.
In this presentation we will look at CFML as a high-quality, efficient programming environment. CFML brings a lot to the table. With CFML you can:
We will also look at the Open CFML advisory committee's work in standardizing the language to ensure that it works consistently across engines and at choosing the right CFML engine for you.
Jason Dean - Jason is a Web Application Developer with the Minnesota Department of Health, in St. Paul. He has been working in Information Technology for 12 years and is a veteran of the U.S. Coast Guard. He manages a ColdFusion User Group at the MN Department of Health and is a board member of the Twin Cities ColdFusion User Group. He is also a conference speaker, technical writer, and blogger (http://www.12robots.com).
Even with all the hype and buzz around dynamic languages in the last few years you might still have overlooked Lua. Used primarily as a scripting and extension language for games like World of Warcraft, Lua is also the language in which the majority of Adobe Lightroom is written. In this talk, I'll provide a brief overview of Lua and then dive headlong into how its virtual machine works and how static analysis of the bytecode can spot mistakes and dead code.
Dan Tull has been a professional software developer for around a decade and taught himself his first 3 programming languages about 6 years earlier (in high school). For the last 3 years he's worked at Adobe Systems on the Lightroom team. Prior to that, he worked on projects ranging from embedded systems to enterprise web applications in industries including financial services, and storage networking, and medical devices.
Objective-C, a fossil of a language from the '80s is resurgent: the language of choice for Mac development and, currently, the only language for iPhone development. In this talk, I'll cover some of the history of Objective-C & Cocoa (the Apple standard library for Mac/iPhone), how it differs to languages like Java or C# that you may be familiar with and show you some interesting techniques that can't be easily accomplished in other languages.
Dan Bennett is Senior Director, New Product Technology for Thomson Reuters based in Eagan, Minnesota, responsible for a team building the next generation of web applications for West. Dan hates to manage things he doesn't understand, so keeps his hand in with a variety of development projects, including leading the development of the first iPhone application for Thomson Reuters.
In this talk, we'll go over the basics of the Scala syntax, introducing just enough object and functional features to get the Scala neophyte deeply enough into the language and environment to make it feasible to read Scala code and begin to understand the wider world that Scala represents. No prior knowledge of Scala is necessary, though a basic working knowledge of the Java environment (notably, how to launch Java applications and a simple understanding of CLASSPATH) helps.
Ted Neward is an independent consultant specializing in high-scale enterprise systems, working with clients ranging in size from Fortune 500 corporations to small 10-person shops. He is an authority in Java and .NET technologies, particularly in the areas of Java/.NET integration (both in-process and via integration tools like Web services), back-end enterprise software systems, and virtual machine/execution engine plumbing.
Most of the time we program in modern languages like Ruby or C#. However, there are a plethora of languages out there that are strange, odd, and/or just plain funny. In this talk, I'll go over a number of esoteric programming languages such as Whenever, Befunge, and LOLCODE. Come with a sense of humor!
Jason Bock is a Principal Consultant for Magenic, and is also a Microsoft MVP. He has worked on a number of business applications using a diverse set of substrates and languages such as C#, .NET, and Java. He is the author of "Applied .NET Attributes", "CIL Programming: Under the Hood of .NET", ".NET Security", and "Visual Basic 6 Win32 API Tutorial". He has written numerous articles on software development issues and has presented at a number of conferences and user groups. He also run the Twin Cities Code Camp and the Twin Cities Languages User Group. Jason holds a Master's degree in Electrical Engineering from Marquette University. Visit his web site at http://www.jasonbock.net.
Try to remember back to what programming language you first learned. It is likely it was some form of BASIC. Whether it was on an Apple IIe, TSR, DOS or TI-89. BASIC has been a staple for teaching programming to kids. MS Dev Labs has come out with a new basic for teaching kids modern programming techniques in both text and GUI interfaces. Utilizing .NET 3.5 and WPF it provides a rich and easy to use experience to cover everything from variable assignment, to loops and subroutines.
In this talk we'll go over the "basics" of this 15 keyword BASIC implementation. We will cover how easy it is for you to teach your kids how programming works in a way that then end result will make them say "wow". We will also cover the extension mechanism to add your own classes/api's into the system.
Maybe you can once again discover the joy you felt when you first learned "Hey, I can do that" with that first programming language.
Jeff Klawiter is a Senior .NET Developer at Sierra Bravo Corporation. His ambitions in life are to learn all there is to know about programming before he dies and to one day make his own dragon with Biological Programming.
The first step in any source compilation is to analyze the source code's syntax so that it can be understood and translated into a target instruction set. But just how does this step work? In this talk, I'll discuss lexical analysis: the process by which a file full of code is systematically dissected into the identifiers, keywords and symbols that make up the source. Included will be a discussion on regular expressions, state machines, the tools used for lexical analysis today, and how all of this might be implemented in today's .NET world.
Jeff Ferguson is a Consulting Manager with Magenic. He has been with Magenic since 1996 and has worked in the software development community since 1989. Jeff has developed code for the Microsoft space during all of that time and has been involved in a variety of both desktop and Web-based projects using C, C++, C# and Visual Basic .NET. Visit his blog at http://www.geekswithblogs.net/JeffFerguson/.
Ruby's monkeypatching brought the idea of metaprogramming to the masses, or at least to those that weren't exposed to it in Lisp or C. At its best, metaprogramming can greatly improve productivity, as is the case with Grails, but at its worst it can destroy expectations and induce versioning confusion. This talk introduces the myriad metaprogramming techniques Groovy and dynamic typing allows, shows how some of them are used in real life, and compares them to what's available in other languages. Oh yeah, all code will be written live.
Hamlet D'Arcy has been writing software for about a decade, and has spent considerable time coding in C++, Java, and Groovy. He's passionate about learning new languages and different ways to think about problems, and recently he's been discovering the joys of both F# and Scheme. He's an active member of the Groovy Users of Minnesota and the Object Technology User Group, is a contributor to a few open source projects (including Groovy and the IDEA Groovy Plugin), blogs regularly at http://hamletdarcy.blogspot.com and can be contacted at hamletdrc@gmail.com.
Scott Vlaminck has been developing web applications for about a decade, and has spent most of that time using Java and J2EE. For the past two years, however, he's been enjoying the freedom of programming in Groovy using Grails. He's an active member of the Groovy Users of Minnesota and has contributed to both the Grails and Groovy projects. His weblog can be found at http://refactr.com/blog and he can be contacted at scott@refactr.com.
Just a few short years ago, when you talked about Java, you were referencing a language and a platform; today, that's no longer the case. Long a friendly home to hundreds of languages, the JVM proudly hosts a slew of first class citizens, from JRuby to Groovy to Scala.
In this talk we'll discuss the transition from Java the language to Java the platform, the drivers of that metamorphosis, and what it means to today's busy developers. We'll touch on the ployglot programmer meme and why it's such an exciting time to be a hacker.
The "Oslo" modeling language can define schemas and transformations over arbitrary text formats. This session shows you how to build your own Domain Specific Language using the "Oslo" SDK and how to apply your DSL to create an interactive text editing experience.
Jason Olson is a Technical Evangelist in Microsoft's Developer and Platform Evangelism (DPE) division, working on core improvements in Visual Studio 2010 and the .NET Framework 4.0. In his minimal spare time, he loves to spend time with his wife and son, play/perform/arrange/compose jazz music, and study programming languages.
Boo is a new object oriented statically typed programming language for the Common Language Infrastructure with a Python-inspired syntax and a special focus on language and compiler extensibility. In this discussion I will be showing some practical examples of BOO and talk about some of the benefits it may offer.
Justin Chase is a .NET developer and is the lead on the open source project NBusiness. He has a special interest in DSLs and programming languages. In the rest of his spare time he likes to travel, play paintball, brew beer and play games.
Arc is a new dialect of Lisp focused on minimizing the size of source code while maximizing productivity, particularly for relatively simple web-based applications. This session will introduce participants to the Arc programming model, as well as the Arc development ecosystem as it exists today.
Kurt Christensen is a complete idiot, and always has been, although Kurt's idiocy wasn't unleashed onto the software community until 1995. Kurt has been weaseling his way into interesting coding gigs ever since, always underqualified for the task at hand. For the past four years, Kurt has also subtracted value from organizations as an "agile" snake oil salesman. Kurt still tries to code as often as possible, but the agile stuff pays more per hour, so of course you can see the difficulty.
Microsoft's High-Level Shader Language (HLSL) is a shading language developed to give graphics programmers complete control over the graphics in their applications. This talk starts at the very basics explaining what a shader is, how it works, how to write one, and why they're so important in the future of next-gen graphics.
Matt Christian is a student at the University of Wisconsin – Stout studying Applied Mathematics and Computer Science with a concentration in Software Development. In 2006 he was the outstanding graduate in the IT – Programmer/ Analyst degree at Northcentral Technical College. He has been programming game demos since high school and has been actively learning DirectX, OpenGL, XNA, and other game related topics. You can find out more about his current projects at http://www.insidegamer.org/projects.aspx or http://www.geekswithblogs.net/CodeBlog.
PowerShell is Microsoft's latest command line shell, formerly codenamed Monad. But PowerShell isn't just for administrators. Though they might not admit it, PowerShell is .NET's first scripting language. Learn how PowerShell's constructs combine a shell and programming language and leverage its powerful capabilities into your own environment.
Neil Iversen thrives on digging into business issues and (ab)using technology to solve a problem. As Lead Developer for Inetium, Neil gets to create solutions that span multiple technologies including SharePoint, CRM, Office and a variety of platforms. He is also a frequent speaker at the Minnesota SharePoint User Group (MNSPUG) and creator of the Minneapolis Office Developer Interest Group (MODIG).
JRuby is the only other production-ready Ruby implementation, and it's starting to see wide deployment. Whether you're building web applications, GUI applications, Java testing frameworks, or just playing around with Java APIs, JRuby has a lot to offer. And there's more to come.
This talk will focus on practical details of Ruby and JRuby, showing why Ruby is such a flexible language and how Ruby combined with the JVM is better than either alone. We'll show off GUI frameworks, graphics demonstrations, web app development and deployment, and maybe more. We'll talk about the status of JRuby in relation to Ruby versions and what's left to implement. Then we'll take a look into JRuby's future, discussing the challenges of keeping up with a development version of Ruby along with other JVM languages that keep moving forward.
Charles Nutter has been working full-time on JRuby at Sun Microsystems for almost two years. He has now expanded his job to include outreach to the JVM language community and hopes to pull more JRuby subsystems out as reusable libraries to help other language implementers. Charles blogs at headius.blogspot.com.