FORM+CODE is the latest book by Casey Reas, Chandler McWilliams + LUST and published by Princeton Architectural Press. The book offers an insight into design by code used by designers, artists and architects to explore and derive to new ways of generating and translating ideas. Broken down into eight chapters, the book attempts to categorise different techniques used in creative code through both current work and historical references and precedents. It also acts as an introduction to anyone interested in this area or work providing both visual and code examples to get quickly started thinking about code as creative medium.
Whilst somewhat lacking theoretical point of view, FORM+CODE explores work through more practical application categorising and giving examples of different techniques. These include Repeat, Transform, Parameterize, Visualize And Simulate. Each one is further broken down to for example REPEAT; Qualities of Repetition, The Computer’s Talent, Modularity, Repetition Technique: Pattern, Repetition Technique: Recursion as well as offering actual code examples you can download from the website. It is a clear classification of most popular techniques used and although by no means comprehensive in describing the pieces it does acknowledge the body of work they each encompass. FORM+CODE is neither a technical guide and it does not provide tutorials or step by step directions to how any of these techniques work. The book is about the state of creative code now in reference to the past. It is a clear and elegant collection of ideas and pieces of work that have influenced, inspired and continue to incite new generations working with digital media. The book is also a fantastic resource for anyone who wants to learn code, not from the technical point of view but more as a reference to how the work is derived to. It is a collection of methods, their application and the possible output.
Casey and Chandler have done a wonderful job in collecting some of the most stunning work out there and LUST in assembling it. Whilst we have seen many books that offer step by step guides there have been very few if any that provide such an enjoyable collection of the work by artists, architects and designers using code in the work. Back to back it is filled with wonderful imagery and not just from the current era but images such as the one of Ivan Sutherland. Beautifully laid out with clear graphic distinction between the chapters and example pages makes it a wonderful read. Highly recommended!
Once the exclusive domain of programmers, code is now being used by a new generation of designers, artists, and architects eager to explore how software can enable innovative ways of generating form and translating ideas. Form+Code in Design, Art, and Architecture offers an in-depth look at the use of software in a wide range of creative disciplines. This visually stimulating survey introduces readers to over 250 signiﬁcant works and undertakings of the past 60 years in the ﬁelds of ﬁne and applied art, architecture, industrial design, digital fabrication, visual cinema, photography, typography, interactive media, gaming, artiﬁcial intelligence (AI), artiﬁcial life (a-life), and graphic design, including data mapping and visualizations, and all forms of new media and expression.
We are also pleased to say that we have one copy of the book to giveaway. All you have to do is Tweet this and you will be entered in the random draw next friday. Read below for Rules and Information.
One lucky winner will be chosen next Monday (4th Oct).
Contest now closed! 270 Entries and random winner is: Edwin Beauchamp aka @sleepysleepyed
Make sure you are following @creativeapps as we will send you a DM if you are a winner.
Rules and information
1. Postage and Packing included.
2. Competition is open to everyone and anyone but you must be over 18 years of age. There will be a total of ONE winner for this competition.
3. Winner will be selected by random.
4. Winner will be contacted via email and will be asked to provide their full name and postal address. If they wish to pass on the book to another person, we will need their name and postal address. If the winner does not respond by the following Monday (11th Oct) we will pick another winner.
5. Only one entry per person.
- Designing Programs [Theory] (This essay was commissioned by Centre national des arts plastiques for Graphisme en France 2012) - Edited by Casey Reas and Chandler McWilliams - Technical mastery and innovation are part of the rich history of visual design. The printing press is the quintessential example of how a shift in design technology can ripple through society. In the Twenty-First Century, innovation in design often means pushing the role of computers within the visual arts in new directions. Writing software is something that's not typically associated with the work of a visual designer, but there's a growing number of designers who write custom software as a component of their work. Over the last decade, through personal experience, We've learned many of the benefits and pitfalls of writing code as a component of a visual arts practice, but our experience doesn't cover the full spectrum. Custom software is changing typography, photography, and composition and is the foundation for new categories of design practice that includes design for networked media (web browsers, mobile phones, tablets) and interactive installations. Most importantly, designers writing software are pushing design thinking into new areas. To cut to the core of the matter, we asked a group of exceptional designers two deceptively simple questions: 1. Why do you write your own software rather than only use existing software tools? 2. How does writing your own software affect your design process and also the visual qualities of the final work? The answers reflect the individuality of the designers and their process, but some ideas are persistent. The most consistent answer is that custom software is written because it gives more control. This control is often expressed as individual freedom. Another thread is writing custom software to create a precise realization for a precise idea. To put it another way, writing custom code is one way to move away from generic solutions; new tools can create new opportunities. Experienced designers know that off-the-shelf, general software tools obscure the potential of software as a medium for expression and communication. Writing custom, unique tools with software opens new potentials for creative authorship. LUST / lust.nl In our studio, form is a result of an idea, which is the result of a process. When approaching a project we try to be as open as possible. Through research and analysis we let the idea emerge from something already embedded in the project itself. Something that was perhaps already present, but that needed to be highlighted. From there we look for the best way to execute that idea, and in doing so develop the form and concept further. Because we approach projects in this way, existing software/tools are often insufficient to properly execute an idea. We also tend to arrive at ideas that require new ways of thinking about how to deal with everything from typography to data to interactivity. In these cases the development of custom software and tools is a natural extension of the process, and can be instrumental in the development of the idea. While designing in code is quite different from ‘traditional’ design methods, these kinds of processes have always been present in our work. Since we started our studio 15 years ago, we have adhered to a process-based methodology in which an analytical process leads eventually to an end-product that designs itself. This coincides very well with the idea of writing your own code and building your own tools. The transition to these kinds of working methods from more traditional approaches was a very natural one. At a certain moment you realize that there is no other way to execute an idea than to build it yourself from the ground up. This frees you from the constraints of pre-packed software and allows you to maintain a closeness to your ideas that wouldn’t be otherwise possible. While any medium will have an impact on the visual outcome of a project, we feel that building your own project-specific tools gives you back the opportunity to control and manipulate the inherent visual qualities of the tools your using. In the end, the visual quality of a work should be relevant to the project itself, rather than rooted in a particular approach or technique - the outcome should speak for itself. LUST's cover for the book Form+Code in Design, Art, and Architecture is generated from frames taken from the movie 2001 A Space Odyssey. Together with the back cover and front matter of the book, the circle is revealed as an O, spelling FORM+CODE. Nicholas Felton / feltron.com A few years ago my work became almost exclusively data-driven and my design process became increasingly centered on a rules-based approach. I developed a set of processes for creating maps and charts that were effective, yet laborious and time consuming. It soon became apparent that in order to produce more and to tackle larger data sets, I would need to find a way to automate the routines I relied on. With Processing, I have been able to design applications that channel my methods, instead of bending my approach to work with existing software. These applications are accountable, so that if the output doesn't match my expectations I am able to audit the code and find the issue. They are also inherently malleable, allowing me to mold the code to fit each project. When I first began writing software, the programs I designed simply allowed me to do more of the same work in a shorter period of time and in a more flexible manner. As a result, the final product was not impacted by the use of software. With more practice and familiarity with the tools, I have started to produce work that would have been unfeasible or impractical using manual methods. I have experimented with maps that rely on difficult algorithms and developed tools that allow me to test a range of variables before outputting a final visualization. Spread from the 2010 Feltron Annual Report, designed by Nicholas Felton. The 2010 Annual Report catalogs the life of Felton's father, who passed away earlier in the year, Amanda Cox (The New York Times) / nytimes.com Mad Libs is a game where key words in a short story have been replaced with blanks. Players fill in the blanks with designated parts of speech ("noun", "adverb") or types of words ("body part", "type of liquid"), without seeing the rest of the story. Occasionally, hilarity ensues, but no one really believes that this is an effective method for generating great literature. In the same way, fill-in-the-blank templates rarely generate great news graphics. Admittedly, generic solutions work perfectly well in some cases. For example: "The _______ (stock index) has fallen _______ (adverb) since _______ (year). [Line chart]." But these are rarely the sorts of graphics that reveal anything unexpected or inspire new ways of looking at the world. Instead, some of the most compelling news graphics exploit structure that is unique to a particular data set. This may require more control than a prepackaged solution, as the same form applied to a different topic would reveal nothing of interest. But if you are nimble enough with points and lines and text, you can do pretty much whatever you want. And this means you get to spend your time exploring and dreaming and wondering "what if" and instead of trying to override the default choices in a software program. If you get lucky, it might even infuse the work with a sense of wonder. This news graphic by The New York Times shows discontent with the political party in power. Nearly all districts voted more Republican (red arrows) in 2010 than they did in 2008. Erik van Blokland (LettError) / letterror.com When I started developing my own tools, I became more critical of existing tools. I had less patience for limitations imposed by others. Building tools offers a powerful perspective on design: the code is there to serve the idea, not the other way round. It means fewer compromises, and when there are compromises to make, at least they are mine and easier to live with. I don't think I am a purist, I will happily use existing tools if they are fit to the task (with wildly varying criteria). But the idea, the direction of a design, should lead the process, not the arbitrary limitations imposed by existing tools. When something can't be done with a specific tool, one should try to improve it or build a better one, but not necessarily compromise the idea. Good ideas are rare, we need to patiently farm millions of them to find one. Killing them before they grow is wasteful. In some of my projects the code gets to touch the shapes. Like filters that synthesize detail or generate patterns or texture. Complex things can be generated (relatively) quickly and evaluated. Doing such things "by hand", even while using a computer could take much longer, forcing me to commit to a set of parameters without realizing the full implications. These kinds of projects are very specific, personal and close to the design. Write, generate. Evaluate. Tweak (code, parameters or both), generate again, repeat. Design iterations are code iterations, the code is as open ended as the design. But often though my code seems to be behind the screen, not touching the shapes directly, enabling directions, whole trees of trees of designs. For instance libraries that standardize objects representing specific data, or an open, documented file format to replace a proprietary and undocumented "industry standard." These abstractions makes it a bit harder (sometimes) to find the energy to build, but the tools that grow on them are very powerful. Here structure and collaboration are important. At which level are the things we agree on and can share, and where are we going to go our own way? These are very interesting questions. Difficult to answer, but part of a very interesting discourse about creative work (design, art, more code) about the methods we have (and the ones we'd like). The top letters are from typefaces that have been designed and generated with Erik van Blokland's tools: Trixie HD, Eames, Federal. The images below are Robot fonts created with Just van Rossum, the Superpolator color field and the roboFab object model. onformative / onformative.com Existing software often restricts implementation possibilities and can even predetermine solutions by dictating what can be done with these possibilities. By writing our own software we break through such barriers and simultaneously create new ways of working with the design process. This process, in which the tool grows and develops with the design, is what excites us. Of course, we also use existing software when it makes sense to do so, because we believe the skillful combination of existing software and our own software is the most effective way to reach the best results. Ultimately, one rarely writes everything anew but rather builds on existing components, or takes elements from the libraries or code snippets of others. One combines the existing with the new, and, through this combination, creates new results based on one’s own ideas. This is possible thanks to the active exchange in communities like the processing.org forum. The design process is no longer divided into concept, design, and production, but rather the design process blends with the production process and the product is created in many small iteration steps in which idea, design, and programming are always closely entwined. When writing one's own software, the creative work and the implementation of these are mutually dependent, and the separation of design and production is abolished. Because one has very different insight into the working methods and detailed processes of one’s own software, there is far more room for experimentation at one’s disposal, which has a direct effect on the quality of the work. “Fragments of RGB” by onformative is a disintegration of an LED screen as an interactive installation and a series of photographs of the transformation. Catalogtree / catalogtree.net You are what you eat. We write our own software mainly to automate repetitive tasks but it is also important to us as a part of our ongoing attempts at experimental tool-making. Choosing a production technique is an important design decision to us and building tools, hardware or software, is a way of avoiding obvious choices. But this process is uncertain, tinkering really. We are amateurs at it by choice. So not all tools find their way into commissioned work: we still have no direct use for our iPod controlled carrousel slide-projector, a fairly accurate push pin firing device for moving targets, a 3D scanner, water rockets or a swarm of vibrobots to draw on a printing screen. But what is important is the belief that the most beautiful sites are just outside the reservation. Programming is the process. Some time ago, we spend a year working on separate locations. Daniel worked in an office building in Rotterdam (great view), and Joris was working from a studio in his backyard (whistling birds). We designed by talking on the phone. Though it was not ideal at all, it wasn’t completely unnatural to us either. We have our own vocabulary when we discuss projects and sketch by describing designs to each other. This means that most of our designs are language-based and finished before becoming visual. Over the phone, it is of no use to describe every single page of a book, every margin, every adjustment to the kerning of a headline. But to describe a system that generates from the smallest information unit in the content a possible flock of birds, can take five seconds. In swarm systems, the behavior of one unit does not predict the behavior of the swarm as a whole. We aim at designs that have some swarming capacity, where we know what the smallest information unit should do but not what the final design might look like. To us, a good design is more that the sum of its parts. However, good design also means picking the right pink and the right typeface. We will not follow an algorithm in a dogmatic way if it generates the wrong results. It is not in the first place about what the rules are, it is about what you do when you end up in a place not covered by those rules. There is room for a cherry on top. Catalogtree building a crystal radio beneath the gaze of their Thomas Castro woodcut portrait. Boris Müller / esono.com It is quite intriguing that most of the software tools we use in our everyday life resemble a specific activity from the analog world - or even the analog past. Even creative, visual work on the computer is still based on manual input. The designer uses software tools to manually produce a formal output. But creativity is not only about manual work - it is also about ideas. And in terms of ideas, software is a vast space. Like any other language, programming languages are about expressing ideas. They allow one to create enormous complexities that remain consistent and stable. So instead of manually crafting an image, I generate an idea in a formal language and turn this idea into any number of images. Beautiful ideas do not necessarily generate beautiful images. In the design process, I have to work on two different levels. The first one is about turning the idea into an abstract system. The second one is for the translation of the system into a visual form. The translation process is not deterministic. Sometimes it is obvious and strongly related to the abstract system - but very often I have to make a lot of design decisions that are purely based on the quality of the visual outcome. Turning an abstract idea into a meaningful image still needs the mind of a designer. Generative visualization of the poem “Nr. 12” by Eugene Ostashevsky Jonathan Puckey / jonathanpuckey.com I love the feeling of being immersed in the functioning of a visual language of my own making. I put on my developer hat and think about the features and limitations I need as a user. Balancing the authorship I embed through the conceptualization and engineering of the software and the authorship I or others can create by using the software in different ways. When I use my tools, I want to forget about the underlying complexity of their functioning and focus purely on mastering they way my input sparks an output. It splits up the process of design into two. I design the tool and then use it to design with. Often I am able to catch the concept of the project I am working on in the functioning of the tool, making it malleable and explorable while designing with it. I consider my tool based works successful when the viewer is able to visually recognize the collaboration (or even struggle) that is happening between the simplicity of the tool and the complexity of its input. There is No Thirteenth Step designed using Lettering Tool, a Scriptographer typography tool by Jonathan Puckey in 2005. Marcus Wendt (FIELD) / field.io As a student I loved the new aesthetics of modern painting and architecture. I wanted to combine elegant and minimalist structures with complexity and emotional richness – as if bringing together Zaha Hadid with Gerhard Richter. It took many attempts to realize that writing code could play a significant role in getting onto this route. Traditional design tools are following the aging metaphor of a single artist working tediously at his desk creating static images with high manual labour. The more I learned to code I realized how immensely dynamic working with these new tools can be — you can create living digital creatures; films that look different every time you watch, and design tools making 10,000 digital paintings in a day. Writing code follows a bottom-up architectural approach and therefor emphasizes the process over the final result. Instead of working towards a single image, you start to think in the possibilities of a system. Designing a process rather than the end result forces you to be open for and work with unexpected results, and sometimes surprisedly embrace the outcome. It's hard to cheat when you're working with code – before you can write something down, you have to clarify your ideas. It's a bit like planning and building a house – with the major difference that once you're done you can go back and change your foundation to get a dramatically different result. Communion is a site-specific generative installation designed and coded by FIELD, with creative direction by Universal Everything and sound by Freefarm. Image courtesy James Medcraft. Sosolimited / sosolimited.com Programming is a lot like cooking. When you learn how to do it yourself, you derive great pleasure from combining ingredients of your choosing and tasting the resulting dish. After a while, it becomes second nature and you no longer have to rely on processed foods for nutrition. Another similarity between cooking and programming is that they are both powerful instruments of seduction. MIT was instrumental in teaching us this way of thinking. If your tire gets a flat, why buy a new one when you can re-invent the wheel? We were not taught explicitly how to use off the shelf programs. Come to think of it, they didn’t even teach us how to use computers. The attitude was: build whatever it takes to do what you want to do, but use technology to do it. So naturally, when it comes time to design, we write software. When you’re writing your own software, the design is never set in stone. It is a constant improvisation. We don’t always know how our changes will propagate, but a deep trust in the process and a willingness to play often lead to wildly unexpected and pleasing results. It’s like handing your child a marker, writing down a list of things he can and can’t do, and letting him loose in your living room. The visual qualities of our work reflect the structures, iterations, recursions, and limitations of code running on a computer. If we are looking to create an organic visual, we might actively work to hide the digital origin. If we are trying to reveal structures in a stream of information, we might embrace and amplify these same coded qualities. No matter what though, the final work looks the way it does because it is a continuous extension of the thinking machines that made it. Prime Numerics by Sosolimited was a live remix of the final UK Prime Ministerial Debate on 29 April 2010. Trafik / lavitrinedetrafik.fr Graphics and programming are at the very heart of so many of our projects and this association has been the founding basis of Trafik (since 1997). Right from the beginning, we have believed that programming could be used for creative purposes, even if programming languages have essentially been devised to make tools. When we write a program, we are faced with technical issues which we have to address: to resolve the code in order to guarantee the running of the program. However, by studying the generated esthetic results and by making our own visual choices, we have thus adopted an artistic approach. To apply programming to graphic design is an unusual approach by its very nature. In reality, the code, used as the base material, is abstract and disconnected from the generated forms. To write a code, to compile it, and to see it generate itself into tangible shapes, creates a sensitive rapport with programming. Used in such a way in graphic design, it enables us to develop artistic objects which outmatch existing tools. However to constrain ourselves to produce our own instruments is an empirical method which gives correct, precise and adapted results but which also sometimes provokes unexpected results. Thus, the code, by the complexity and diversity of what it can produce, manages to surprise us and to go beyond what we imagined at the outset. For example, the code often generates a unique esthetic which produces a sort of visual radicalism devoid of any sophistication. By using programming, the creative process seems to us to be more complete: when producing visuals, installations or animations, we work first on the functioning of the program, on its “life”. The project builds itself throughout the development, through a permanent exchange between suggestions from the graphic designer and those of the programmer. These two professions and their interactions inspire all of our creations and produce specific and precise objects of art. Pierre Rodière, Graphic Designer / Joël Rodière, Programmer Casey Reas is a professor in the Department of Design Media Arts at UCLA and a graduate of the MIT Media Laboratory. Reas’ software has been featured in numerous solo and group exhibitions at museums and galleries in the United States, Europe, and Asia. With Ben Fry, he co-founded Processing in 2001. He is the author of Process Compendium 2004-2010 and co-author of Processing: A Programming Handbook for Visual Designers and Artists (MIT Press) and Getting Started with Processing (O’Reilly). http://reas.com http://users.dma.ucla.edu/~reas/ Chandler McWilliams is a writer, artist, and programmer. He has studied film, photography, and political science; and completed graduate work in philosophy at The New School For Social Research in New York City. He lives in Los Angeles where he teaches in the department of Design Media Arts at the UCLA School of the Arts. His current work focuses on themes of affect, repetition, computation, and […]
- Decoded [Processing, Events + Giveaway] decoded is a conference about the common ground of design and code. It combines creative and technological aspects of digital life and brings them to an event. From the fields of generative design, information visualization, gaming, interactive installations, physical computing and give deep insights into the works and background. Read on for how to win a free ticket to the event! Speakers at decoded include Massimo Banzi (Arduino), Benedikt Groß & Hartmut Bohnacker, Mario Klingemann, Tilman Reiff & Volker Morawe aka //////////fur//// and Moritz Stefaner. Interestingly, the identity for the conference was designed by envis-precisely who are also event partners/organisers together with reppa.net. The logo, the decorative elements and many other parts of the design were made using Processing. It takes letters and words as input and translates them into polygonal shapes. Play with it here: decoded-conference.com/generator/ The visual coding concept consists of few specified rules for each single letter. The basic geometrie is based on a triangle, each corner stands for a letter within the prompted word. All characters are located on a specific angle of a circle depending on the last position. Triangles are always built on two existing corners together with the currently created vertex. Furthermore this means that new triangles always have a same side with the previous triangle. For shaping the generative appearance the triplets of letters are therefore more important than single letters. When: 23rd October 2010 Where: München/Germany Great news, thanks to the guys at decoded, is that we have one € 99,00 ticket to giveaway. All you have to do is Tweet this and you will be entered in the random draw next friday. Read below for Rules and Information. One lucky winner will be chosen Friday (1st Oct). Winner is @Thibaut Winner is Tyler Townley aka @twicedesign Make sure you are following @creativeapps as we will send you DM if you are a winner. Rules and information 1. The event is being held in München/Germany: www.freiheiz.com on the 23rd October 2010. You will need to arrange your own travel and accommodation (not included) - but the team has a hotelpartner www.decoded-conference.com/ort.php where visitors can get cheaper prices. If you win the ticket and you can't make it to the event, we would appreciate you let us know so we can give the ticket to someone else. 2. Competition is open to everyone and anyone but you must be over 18 years of age. There will be a total of ONE winner for this competition. 3. Winner will be selected by random. 4. Winner will be contacted via email and will be asked to provide their full name and postal address. If they wish to pass on a ticket to another person, we will need their name and postal address. If the winner does not respond by the following Friday (8th Oct) we will pick another winner. 5. Only one entry per […]
- Software Studio – Casey Reas at Resonate 2013 Making an argument for software as a dense medium for visual arts. After doing work for 10 years, in this presentation Casey Reas reflect on the work and tries to put this argument for coding in a wider […]
- OFFF 2010 + Book Giveaway [Events] Just got back from the OFFF festival and once again have met an incredible group of people. Some known, others producing fantastic work and even more of our wonderful readers and followers on Twitter. Got interview by éTapes magazine (coming soon), met the organisers including Thomas and Hector, drank a lot of beer and watched talks about the past present and future of digital media. In case you missed OFFF, we will be posting about the work we've seen in the following few weeks in the meantime we have 5 event catalogues to give away. The catalogues includes the featured artists from the event, loopita, openroom, guest artists selected from submissions all packaged up in 300 or so pages. To win a copy of "Nostalgia for a past future, OFFF Paris 2010" book, all you have to do is tweet this post: (Make sure you follow @creativeapps so we can DM you if you are chosen) 5 Winners will be chosen by random on Tuesday 6th July at 11.00am GMT Contest now over! The winners are: @mynameisfin, @jhelf, @barszczewski, @artofwong and @cpallanti We leave you with the OFFF 2010 opening titles created by the Mill. Rules and information 1. Postage and Packing is included. We just need your address. 2. Competition is open to everyone and anyone but you must be over 18 years of age. There will be a total of FIVE winner for this competition. 3. Winner will be selected by random. 4. Winner will be contacted via email and will be asked to provide their full name and postal address. If they wish to pass on the book to another person, we will need their name and postal address. If the winner does not respond by the following Tue (13th July) we will pick another winner. 5. Only one entry per […]
- Process Compendium [Processing] Process Compendium 2004-2010 is a collection of work and record of process by Casey Reas, co-founder of Processing, presented and created entirely in Processing. If you have seen Casey speak, this is another opportunity to examine and explore generative art Casey has been creating in the past few years. If you haven't, (must) download links below. Spoken by computer voice, you are taken on a journey by Casey through conditions, rules and elements that play a part in the creation of prints, sculptures Casey exhibited worldwide. From early examples of attributed behaviour to simple objects such as lines and circles to complex traces and colour trails these objects create, all resulting in beautiful compositions, captured as fragments of time. An Element is a simple machine that is comprised of a Form and one or more Behaviors. A Process defines an environment for Elements and determines how the relationships between the Elements are visualized. For instance, Element 1 takes the form of a circle and one of its behaviors moves it along a straight line at a constant speed. Process 4 fills a surface with Element 1 and draws a line between elements while they overlap. Each Process is a short text that defines a space to explore through multiple interpretations. More.. Download: Mac | Windows For more work, see […]
- Announcing: CAN + Intel Perceptual Computing Challenge + Giveaway! In collaboration with Intel, CAN is pleased to announce the launch of Intel Perceptual Computing challenge. This is your opportunity to change the way people interface with computers and win a chance at $100,000 and get your app on new Perceptual Computing […]
- Five Days Left To Enter! – Intel Perceptual Computing Challenge What are you waiting for? Intel is looking for the most innovative and unique uses of Perceptual Computing. A grand-prize of $100,000 and thousand of dollars more in prizing are available but you must act […]
- Intel Perceptual Computing Challenge – First Stage Complete After thousands of developers entered the Intel Perceptual Challenge contest by submitting their ideas, 750 have now been selected to receive a camera to continue to the next stage of the […]
Posted on: 27/09/2010
- Senior Digital Designer at CLEVER°FRANKE
- Interaction Designer at Carlo Ratti Associati
- Creative Technologist at Deeplocal
- HTML / CSS Developer at Resn
- Climate Service Data Visualiser at FutureEverything
- Web Developer at &Associates
- Creative Technologist at Rewind FX
- Coder to collaborate with Agnes Chavez
- Data Scientist at Seed Scientific
- Data Engineer at Seed Scientific
- Design Technologist at Seed Scientific
- Creative Technologist, The ZOO at Google