Richard Farman and Ben Limpich reflect on working alongside Paul Carduner on open source software in Seattle.

My helpful screenshot

July 2nd marked the end of our first full month interning at Carduner Consulting. We’ve been frying our brains learning new concepts, spending late nights at the office debugging code, and striving to find the best lunch spot in downtown Seattle. We’ve even picked up a clever nickname, PBR, which was given to us by one of the Apptentive employees when he heard that our names were Paul, Ben, and Richie.

The folks at Apptentive have been nice enough to host us for the summer, hooking us up with all the resources and benefits the tech industry is known for — mice, keyboards, monitors, our own office, and a fully stocked kitchen with fresh local coffee and craft beer on tap. It’s a privilege to be surrounded by the high energy and enterprising spirit of a startup credited as the most desirable small company to work for in Seattle, so we’ve been working to make the most of our time here.

What we’re building

The main focus of our time at Carduner Consulting is constructing a web-based IDE for the Pyret runtime. Pyret is an educational programming language, but with pragmatic applications, and under active design and development as an open source project. Capable for functional programming and scripting, it makes a great choice for those learning how to program or trying to take their skills to the next level. Pyret is a fresh take on Computer Science education, combining modern design with practical development, and we couldn’t be more excited to be a part the project.

Currently, the Pyret website hosts a functioning platform that contains an Integrated Development Environment (IDE), which is essentially a sandbox for people to play around with the language. You can write, compile, and run code all in one package. However, while the back-end is impressive, the site itself is in need of an overhaul. That’s where we come in. Using tools like React, Redux, and Node.js we’re rebuilding the front-end IDE from scratch, rethinking user experience and adding new features to make it more responsive and dynamic.

Our website begins with the basics, HTML and CSS. These markup languages are ubiquitous among web applications, forming the basis of the front-end Document Object Model(DOM), which are the blueprints to the structure of a web page. However, despite their widespread usage, HTML and CSS come with a host of issues that make building reactive websites more difficult than it should be.

That’s why we’re using React.js, a contemporary method of creating interactive User Interfaces (UI) used in web applications like Facebook and Instagram. When it comes to React, what you see is what you get, linking the UI with the DOM to ensure a cohesive user experience. React refines the rendering and updating process, creating a hierarchy of controlled components that we put together like building blocks to form a new and improved UI.

To further streamline our application, we are using Redux.js, a predictable state container that holds the data of our website. This allows us to directly link the data of our application to the user’s actions by creating pure functions that efficiently and asynchronously update the state of the website, tying actions directly to state for consistent communication between the user and the platform.

With modern tools come modern conveniences, and using Jasmine, never before has it been easier to test our applications. Creating tests for code is an often underappreciated and overlooked part of web development. When something goes wrong in your application, it’s incredibly useful to know exactly what went wrong and where so that fixing issues is a trivial matter. No confusion, no guessing games, no searching through hundreds of lines of code, just simple tests. Writing tests is something of an art form, and one of the more surprisingly interesting aspects of our work.

Server side, we’re using Node.js, a cross-platform runtime environment optimized for asynchronous applications. Along with Node comes npm, a package manager that allows us to seamlessly integrate modules from other users, making collaboration and code-sharing a breeze. There’s an active community creating packages for other users to share, all trying to make each other’s lives easier! It’s a great resource for us as we encounter complex challenges in our development.


This internship has been more challenging than anything we’ve previously attempted, both technically and creatively. The learning curve is steep, the ideas abstract, utilizing tools and technologies we had never experienced before this internship. But under the guidance of Paul Carduner, we have been slowly but surely implementing what seemed at the start as an insurmountable task. We can feel ourselves growing as developers, discovering new ideas and practices everyday, becoming stronger to meet higher standards. It’s both exciting and satisfying, personally and professionally.

As students of Whitman College, we are on the forefront of a tech revolution manifesting in our growing Computer Science program that seeks to bring in students across backgrounds and disciplines, and teach them about all the amazing things Computer Science can accomplish. With the benefit of a liberal arts education, Whitman students are experienced problem-solvers, with quick wit and thoughtful minds. They all would make great developers, although not all of them may realize it. Our program offers them a glimpse of that world, in the hopes that it may light that spark within them.

As with most educational programs, Computer Science at Whitman is focused primarily on the theories and principles of Computer Science. Although the projects offer glimpses of real-world applications, there is a stark difference between homework programming and industrial programming. In a classroom environment, you are guided through textbooks, lectures, assignments, with all the support of your classmates and professors. If you don’t fully understand a topic, or can’t quite finish a project, you simply do your best, receive a grade, and move on.

That’s not how it works in the industry. Everything you do must be 100%, and not only must the code work the way it’s supposed to, it should be written flawlessly, standing up to any discretion. Mistakes are quickly exposed through the widespread network of users and cases, so your code must be solid against any attempt to break it. This is not an easy thing to do, and quickly we realized there’s never such a thing as ‘good enough’. It’s all a matter of what you can prioritize and how much you can accomplish. This may sound daunting, but it’s more encouraging than anything else. It’s only a question of “how can we make life better for other people?”

Although the industry is much different from the classroom, we owe much to our experiences in school, which have given us a comprehensive understanding of all the underlying principles beneath our code. This has much in common with the philosophy behind Pyret, which seeks not only to give us the fundamentals for tackling these tasks, but the inspiration and environment for developing connections between the theories of Computer Science to real-world applications. Undergoing that transition ourselves, we hope to make it more accessible to prospective students in the future.  At Carduner Consulting, we seek not only to further our own development, but also foster growth throughout the Computer Science community.

Peace, Love, and Algorithms

The 2016 Carduner Consulting Interns Richard Farman and Ben Limpich

tl;dr: We’ve been working hard and got nicknamed after a beer