DOCSLIB.ORG

A Compiler-Compiler for DSL Embedding

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
A Compiler-Compiler for DSL Embedding A Compiler-Compiler for DSL Embedding Amir Shaikhha Vojin Jovanovic Christoph Koch EPFL, Switzerland Oracle Labs EPFL, Switzerland {amir.shaikhha}@epfl.ch {vojin.jovanovic}@oracle.com {christoph.koch}@epfl.ch Abstract (EDSLs) [14] in the Scala programming language. DSL devel- In this paper, we present a framework to generate compil- opers define a DSL as a normal library in Scala. This plain ers for embedded domain-specific languages (EDSLs). This Scala implementation can be used for debugging purposes framework provides facilities to automatically generate the without worrying about the performance aspects (handled boilerplate code required for building DSL compilers on top separately by the DSL compiler). of extensible optimizing compilers. We evaluate the practi- Alchemy provides a customizable set of annotations for cality of our framework by demonstrating several use-cases encoding the domain knowledge in the optimizing compila- successfully built with it. tion frameworks. A DSL developer annotates the DSL library, from which Alchemy generates a DSL compiler that is built CCS Concepts • Software and its engineering → Soft- on top of an extensible optimizing compiler. As opposed to ware performance; Compilers; the existing compiler-compilers and language workbenches, Alchemy does not need a new meta-language for defining Keywords Domain-Specific Languages, Compiler-Compiler, a DSL; instead, Alchemy uses the reflection capabilities of Language Embedding Scala to treat the plain Scala code of the DSL library as the language specification. 1 Introduction A compiler expert can customize the behavior of the pre- Everything that happens once can never happen defined set of annotations based on the features provided by again. But everything that happens twice will a particular optimizing compiler. Furthermore, the compiler surely happen a third time. expert can extend the set of annotations with additional ones – Paulo Coelho, The Alchemist for encoding various domain knowledge in an optimizing Domain-specific languages (DSLs) have gained enormous compiler. success in providing productivity and performance simulta- This paper is organized as follows. In Section 2 we review neously. The former is achieved through their concise syntax, the background material and related work. Then, in Section 3 while the latter is achieved by using specialization and com- we give a high-level overview of the Alchemy framework. In pilation techniques. These two significantly improve DSL Section 4 we present the process of generating a DSL com- users’ programming experience. piler in more detail. Section 5 presents several use cases built Building DSL compilers is a time-consuming and tedious with the Alchemy framework. Finally, Section 6 concludes. task requiring much boilerplate code related to non-creative aspects of building a compiler, such as the definition of inter- 2 Background & Related Work mediate representation (IR) nodes and repetitive transforma- In this section, we present the background and related work tions [2]. There are many extensible optimizing compilers to better understand the design decisions behind Alchemy. to help DSL developers by providing the required infrastruc- ture for building compiler-based DSLs. However, the existing 2.1 Compiler-Compiler arXiv:1808.01344v1 [cs.PL] 3 Aug 2018 optimizing compilation frameworks suffer from a steep learn- A compiler-compiler (or a meta compiler) is a program that ing curve, which hinders their adoption by DSL developers generates a compiler from the specification of a program- who lack compiler expertise. In addition, if the API of the ming language. This specification is usually expressed ina underlying extensible optimizing compiler changes, the DSL declarative language, called a meta-language. developer would need to globally refactor the code base of Yacc [17] is a compiler-compiler for generating parsers the DSL compiler. specified using a declarative language. There are numerous The key contribution of this paper is to use a generative systems for defining new languages, referred to as language approach to help DSL developers with the process of build- workbenches [9, 12], such as Stratego/Spoofax [19], Sug- ing a DSL compiler. Instead of asking the DSL developer to arJ [7], Sugar* [8], KHEPERA [10], and MPS [16]. provide the boilerplate code snippets required for building a DSL compiler, we present a framework which automatically generates them. 2.2 Domain-Specific Languages More specifically, we present Alchemy, a language work- DSLs are programming languages tailored for a specific do- bench [9, 12] for generating compilers for embedded DSLs main. There are many successful examples of systems using DSLs in various domains such as SQL in database manage- DSL Developer Compiler Expert ment, Spiral [28] for generating digital signal processing Kiama LMS SC Kiama LMS SC kernels, and Halide [29] for image processing. The software Plugin Plugin Plugin Annotated Alchemy development process can also be improved by using DSLs, Shallow IR Nodes Deep EDSL Expression EDSL referred to as language-oriented programming [40]. Cade- Lifting lion [23] is a language workbench developed for language- Annotations oriented programming. Interpreter Compiler-Compiler Compiler There are two kinds of DSLs: 1) external DSLs which have a stand-alone compiler, and 2) embedded DSLs [14] (EDSLs) Figure 1. Overall design of Alchemy. which are embedded in another generic-purpose program- ming language, called a host language. Various EDSLs have been successfully implemented in dif- EDSL using a particular extensible optimizing compiler. In ferent host languages, such as Haskell [1, 14, 24] or Scala [21, other words, Alchemy converts an interpreter for a language 25, 30, 33]. The main advantage of EDSLs is reusing the ex- (a shallow EDSL) to a compiler (a deep EDSL). isting infrastructure of the host language, such as the parser, Truffle [15] provides a DSL for defining self-optimizing the type checker, and the IDEs among others. AST interpreters, using the Graal [41] optimizing compiler as There are two ways to define an EDSL. The first approach the backend. This system mainly focuses on providing just- is by defining it as a plain library in the host language, re- in-time compilation for dynamically typed languages such ferred to as shallowly embedding it in the host language. as JavaScript and R, by annotating AST nodes. In contrast, A shallow EDSL is reusing both the frontend and backend Alchemy uses annotation on the library itself and generates components of the host language compiler. However, the the AST nodes based on strategy defined by the compiler opportunities for domain-specific optimizations are left un- expert. exploited. In other words, the library-based implementation Forge [38] is an embedded DSL in Scala for specifying of the EDSL in the host language is served an interpreter. other DSLs. Forge is used by the Delite [21] and LMS [30, 31] The second approach is deeply embedding the DSL in the compilation frameworks. This approach requires DSL devel- host language. A deep EDSL is only using the frontend of the opers to learn a new specification language before imple- host language, and requires the DSL developer to implement menting DSLs. In contrast, Alchemy developers write a DSL a backend for the EDSL. This way, the DSL developer can specification using plain Scala code. Then, domain-specific leverage domain-specific opportunities for optimizations knowledge is encoded using simple Alchemy annotations. and can leverage different target backends through code Yin-Yang [18] uses Scala macros for automatically convert- generation. ing shallow EDSLs to the corresponding deep EDSLs. Thus, it completely removes the need for providing the definition 2.3 Extensible Optimizing Compilers of a deep DSL library from the DSL developer. However, con- There are many extensible optimizing compilers which pro- trary to our work, the compiler-compilation of Yin-Yang is vide facilities for defining optimizations and code genera- specific to the LMS30 [ ] compilation framework. Also, Yin- tion for new languages. Such frameworks can significantly Yang does not generate any code related to optimizations of simplify the development of the backend component of the the DSL library. We have identified the task of automatically compiler for a new programming language. generating the optimizations to be not only a crucial require- Stratego/Spoofax [19] uses strategy-based term-rewrite ment for DSL developers but also one that is significantly systems for defining domain-specific optimizations for DSLs. more complicated than the one handled by Yin-Yang. Stratego uses an approach similar to quasi-quotation [39] to hide the expression terms from the user. For the same pur- 3 Overview pose, Alchemy uses annotations for specifying a subset of Figure 1 shows the overall design of the Alchemy framework. optimizations specified by the compiler expert. One canuse Alchemy is implemented as a compiler plugin for the Scala quasi-quotes [26, 34] for implementing domain-specific opti- programming language.1 After parsing and type checking mizations in concrete syntax (rather than abstract syntax) the library-based implementation of an EDSL, Alchemy uses similar to Stratego. the type-checked Scala AST to generate an appropriate DSL compiler. The generated DSL compiler follows the API pro- 2.4 What is Alchemy? vided by an extensible optimizing compiler to implement Alchemy is a compiler-compiler, designed for EDSLs that transformations
Load more

Recommended publications
  • About ILE C/C++ Compiler Reference
    IBM i 7.3 Programming IBM Rational Development Studio for i ILE C/C++ Compiler Reference IBM SC09-4816-07 Note Before using this information and the product it supports, read the information in “Notices” on page 121. This edition applies to IBM® Rational® Development Studio for i (product number 5770-WDS) and to all subsequent releases and modifications until otherwise indicated in new editions. This version does not run on all reduced instruction set computer (RISC) models nor does it run on CISC models. This document may contain references to Licensed Internal Code. Licensed Internal Code is Machine Code and is licensed to you under the terms of the IBM License Agreement for Machine Code. © Copyright International Business Machines Corporation 1993, 2015. US Government Users Restricted Rights – Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp. Contents ILE C/C++ Compiler Reference............................................................................... 1 What is new for IBM i 7.3.............................................................................................................................3 PDF file for ILE C/C++ Compiler Reference.................................................................................................5 About ILE C/C++ Compiler Reference......................................................................................................... 7 Prerequisite and Related Information..................................................................................................
    [Show full text]
  • Compiler Error Messages Considered Unhelpful: the Landscape of Text-Based Programming Error Message Research
    Working Group Report ITiCSE-WGR ’19, July 15–17, 2019, Aberdeen, Scotland Uk Compiler Error Messages Considered Unhelpful: The Landscape of Text-Based Programming Error Message Research Brett A. Becker∗ Paul Denny∗ Raymond Pettit∗ University College Dublin University of Auckland University of Virginia Dublin, Ireland Auckland, New Zealand Charlottesville, Virginia, USA [email protected] [email protected] [email protected] Durell Bouchard Dennis J. Bouvier Brian Harrington Roanoke College Southern Illinois University Edwardsville University of Toronto Scarborough Roanoke, Virgina, USA Edwardsville, Illinois, USA Scarborough, Ontario, Canada [email protected] [email protected] [email protected] Amir Kamil Amey Karkare Chris McDonald University of Michigan Indian Institute of Technology Kanpur University of Western Australia Ann Arbor, Michigan, USA Kanpur, India Perth, Australia [email protected] [email protected] [email protected] Peter-Michael Osera Janice L. Pearce James Prather Grinnell College Berea College Abilene Christian University Grinnell, Iowa, USA Berea, Kentucky, USA Abilene, Texas, USA [email protected] [email protected] [email protected] ABSTRACT of evidence supporting each one (historical, anecdotal, and empiri- Diagnostic messages generated by compilers and interpreters such cal). This work can serve as a starting point for those who wish to as syntax error messages have been researched for over half of a conduct research on compiler error messages, runtime errors, and century. Unfortunately, these messages which include error, warn- warnings. We also make the bibtex file of our 300+ reference corpus ing, and run-time messages, present substantial difficulty and could publicly available.
    [Show full text]
  • ROSE Tutorial: a Tool for Building Source-To-Source Translators Draft Tutorial (Version 0.9.11.115)
    ROSE Tutorial: A Tool for Building Source-to-Source Translators Draft Tutorial (version 0.9.11.115) Daniel Quinlan, Markus Schordan, Richard Vuduc, Qing Yi Thomas Panas, Chunhua Liao, and Jeremiah J. Willcock Lawrence Livermore National Laboratory Livermore, CA 94550 925-423-2668 (office) 925-422-6278 (fax) fdquinlan,panas2,[email protected] [email protected] [email protected] [email protected] [email protected] Project Web Page: www.rosecompiler.org UCRL Number for ROSE User Manual: UCRL-SM-210137-DRAFT UCRL Number for ROSE Tutorial: UCRL-SM-210032-DRAFT UCRL Number for ROSE Source Code: UCRL-CODE-155962 ROSE User Manual (pdf) ROSE Tutorial (pdf) ROSE HTML Reference (html only) September 12, 2019 ii September 12, 2019 Contents 1 Introduction 1 1.1 What is ROSE.....................................1 1.2 Why you should be interested in ROSE.......................2 1.3 Problems that ROSE can address...........................2 1.4 Examples in this ROSE Tutorial...........................3 1.5 ROSE Documentation and Where To Find It.................... 10 1.6 Using the Tutorial................................... 11 1.7 Required Makefile for Tutorial Examples....................... 11 I Working with the ROSE AST 13 2 Identity Translator 15 3 Simple AST Graph Generator 19 4 AST Whole Graph Generator 23 5 Advanced AST Graph Generation 29 6 AST PDF Generator 31 7 Introduction to AST Traversals 35 7.1 Input For Example Traversals............................. 35 7.2 Traversals of the AST Structure............................ 36 7.2.1 Classic Object-Oriented Visitor Pattern for the AST............ 37 7.2.2 Simple Traversal (no attributes)....................... 37 7.2.3 Simple Pre- and Postorder Traversal....................
    [Show full text]
  • Spreading Excellence Report
    HIGH PERFORMANCE AND EMBEDDED ARCHITECTURE AND COMPILATION Project Acronym: HiPEAC Project full title: High Performance and Embedded Architecture and Compilation Grant agreement no: ICT-217068 DELIVERABLE 3.1 SPREADING EXCELLENCE REPORT 15/04/2009 Spreading Excellence Report 1 1. Summary on Spreading Excellence ................................................................................ 3 2. Task 3.1: Conference ........................................................................................................ 4 2.1. HiPEAC 2008 Conference, Goteborg ......................................................................... 4 2.2. HiPEAC 2009 Conference, Paphos ........................................................................... 10 2.3. Conference Ranking .................................................................................................. 16 3. Task 3.2: Summer School .............................................................................................. 16 th 3.1. 4 International Summer School – 2008 ................................................................... 16 th 3.2. 5 International Summer School – 2009 ................................................................... 21 4. Task 3.3: HiPEAC Journal ............................................................................................ 22 5. Task 3.4: HiPEAC Roadmap ........................................................................................ 23 6. Task 3.5: HiPEAC Newsletter ......................................................................................
    [Show full text]
  • Basic Compiler Algorithms for Parallel Programs *
    Basic Compiler Algorithms for Parallel Programs * Jaejin Lee and David A. Padua Samuel P. Midkiff Department of Computer Science IBM T. J. Watson Research Center University of Illinois P.O.Box 218 Urbana, IL 61801 Yorktown Heights, NY 10598 {j-lee44,padua}@cs.uiuc.edu [email protected] Abstract 1 Introduction Traditional compiler techniques developed for sequential Under the shared memory parallel programming model, all programs do not guarantee the correctness (sequential con- threads in a job can accessa global address space. Communi- sistency) of compiler transformations when applied to par- cation between threads is via reads and writes of shared vari- allel programs. This is because traditional compilers for ables rather than explicit communication operations. Pro- sequential programs do not account for the updates to a cessors may access a shared variable concurrently without shared variable by different threads. We present a con- any fixed ordering of accesses,which leads to data races [5,9] current static single assignment (CSSA) form for parallel and non-deterministic behavior. programs containing cobegin/coend and parallel do con- Data races and synchronization make it impossible to apply structs and post/wait synchronization primitives. Based classical compiler optimization and analysis techniques di- on the CSSA form, we present copy propagation and dead rectly to parallel programs because the classical methods do code elimination techniques. Also, a global value number- not account.for updates to shared variables in threads other ing technique that detects equivalent variables in parallel than the one being analyzed. Classical optimizations may programs is presented. By using global value numbering change the meaning of programs when they are applied to and the CSSA form, we extend classical common subex- shared memory parallel programs [23].
    [Show full text]
  • Wind River Diab Compiler
    WIND RIVER DIAB COMPILER Boost application performance, reduce memory footprint, and produce high-quality, standards-compliant object code for embedded systems with Wind River® Diab Compiler. Wind River has a long history of providing software and tools for safety-critical applications requiring certification in the automotive, medical, avionics, and industrial markets. And it’s backed by an award-winning global support organization that draws on more than 25 years of compiler experience and hundreds of millions of successfully deployed devices. TOOLCHAIN COMPONENTS Diab Compiler includes the following programs and utilities: • Driver: Intelligent wrapper program invoking the compiler, assembler, and linker, using a single application • Assembler: Macro assembler invoked automatically by the driver program or as a complete standalone assembler generating object modules – Conditional macro assembler with more than 30 directives – Unlimited number of symbols – Debug information for source-level debugging of assembly programs • Compiler: ANSI/ISO C/C++ compatible cross-compiler – EDG front end – Support for ANSI C89, C99, and C++ 2003 – Hundreds of customizable optimizations for performance and size – Processor architecture–specific optimizations – Whole-program optimization capability • Low-level virtual machine (LLVM)–based technology: Member of the LLVM commu- nity, accelerating inclusion of new innovative compiler features and leveraging the LLVM framework to allow easy inclusion of compiler add-ons to benefit customers • Linker: Precise
    [Show full text]
  • Compilers History Wikipedia History Main Article: History of Compiler
    Compilers History Wikipedia History Main article: History of compiler construction Software for early computers was primarily written in assembly language for many years. Higher level programming languages were not invented until the benefits of being able to reuse software on different kinds of CPUs started to become significantly greater than the cost of writing a compiler. The very limited memory capacity of early computers also created many technical problems when implementing a compiler. Towards the end of the 1950s, machine-independent programming languages were first proposed. Subsequently, several experimental compilers were developed. The first compiler was written by Grace Hopper, in 1952, for the A-0 programming language. The FORTRAN team led by John Backus at IBM is generally credited as having introduced the first complete compiler in 1957. COBOL was an early language to be compiled on multiple architectures, in 1960. In many application domains the idea of using a higher level language quickly caught on. Because of the expanding functionality supported by newer programming languages and the increasing complexity of computer architectures, compilers have become more and more complex. Early compilers were written in assembly language. The first self-hosting compiler — capable of compiling its own source code in a high-level language — was created for Lisp by Tim Hart and Mike Levin at MIT in 1962. Since the 1970s it has become common practice to implement a compiler in the language it compiles, although both Pascal and C have been popular choices for implementation language. Building a self-hosting compiler is a bootstrapping problem—the first such compiler for a language must be compiled either by hand or by a compiler written in a different language, or (as in Hart and Levin's Lisp compiler) compiled by running the compiler in an interpreter.
    [Show full text]
  • Compilers and Compiler Generators
    Compilers and Compiler Generators an introduction with C++ © P.D. Terry, Rhodes University, 1996 [email protected] This is a set of Postcript® files of the text of my book "Compilers and Compiler Generators - an introduction with C++", published in 1997 by International Thomson Computer Press. The original edition is now out of print, and the copyright has reverted to me. The book is also available in other formats. The latest versions of the distribution and details of how to download up-to-date compressed versions of the text and its supporting software and courseware can be found at http://www.scifac.ru.ac.za/compilers/ The text of the book is Copyright © PD Terry. Although you are free to make use of the material for academic purposes, the material may not be redistributed without my knowledge or permission. File List The 18 chapters of the book are filed as chap01.ps through chap18.ps The 4 appendices to the book are filed as appa.ps through appd.ps The original appendix A of the book is filed as appa0.ps The contents of the book is filed as contents.ps The preface of the book is filed as preface.ps An index for the book is filed as index.ps. Currently (January 2000) the page numbers refer to an A4 version in PCL® format available at http://www.scifac.ru.ac.za/compilers/longpcl.zip. However, software tools like GhostView may be used to search the files for specific text. The bibliography for the book is filed as biblio.ps Change List 18-October-1999 - Pre-release 12-November-1999 - First official on-line release 16-January-2000 - First release of Postscript version (incorporates minor corrections to chapter 12) Compilers and Compiler Generators © P.D.
    [Show full text]
  • Perl
    -I<directory> directories specified by –I are Perl prepended to @INC -I<oct_name> enable automatic line-end processing Ming- Hwa Wang, Ph.D. -(m|M)[- executes use <module> before COEN 388 Principles of Computer- Aided Engineering Design ]<module>[=arg{,arg}] executing your script Department of Computer Engineering -n causes Perl to assume a loop around Santa Clara University -p your script -P causes your script through the C Scripting Languages preprocessor before compilation interpreter vs. compiler -s enable switch parsing efficiency concerns -S makes Perl use the PATH environment strong typed vs. type-less variable to search for the script Perl: Practical Extraction and Report Language -T forces taint checks to be turned on so pattern matching capability you can test them -u causes Perl to dump core after Resources compiling your script Unix Perl manpages -U allow Perl to do unsafe operations Usenet newsgroups: comp.lang.perl -v print version Perl homepage: http://www.perl/com/perl/, http://www.perl.org -V print Perl configuration and @INC Download: http://www.perl.com/CPAN/ values -V:<name> print the value of the named To Run Perl Script configuration value run as command: perl –e ‘print “Hello, world!\n”;’ -w print warning for unused variable, run as scripts (with chmod +x): perl <script> using variable without setting the #!/usr/local/bin/perl –w value, undefined functions, references use strict; to undefined filehandle, write to print “Hello, world!\n”; filehandle which is read-only, using a exit 0; non-number as it were a number, or switches subroutine recurse too deep, etc.
    [Show full text]
  • Compilers History of Compilers
    Compilers A compiler allows programmers to ignore the Compilers are fundamental to machine-dependent details of modern computing. programming. They act as translators, transforming human-oriented Compilers allow programs and programming languages into programming skills to be computer-oriented machine machine-independent. languages. To most users, a compiler can be viewed as a “black box” that Compilers also aid in detecting performs the transformation programming errors (which are shown below. all too common). Compiler techniques also help to improve computer security. Programming Language Compiler Machine Language For example, the Java Bytecode Verifier helps to guarantee that Java security rules are satisfied. © © CS 536 Spring 2008 10 CS 536 Spring 2008 11 Compilers currently help in History of Compilers protection of intellectual property (using obfuscation) The term compiler was coined and provenance (through in the early 1950s by Grace watermarking). Murray Hopper. Translation was viewed as the “compilation” of a sequence of machine- language subprograms selected from a library. One of the first real compilers was the FORTRAN compiler of the late 1950s. It allowed a programmer to use a problem- oriented source language. © © CS 536 Spring 2008 12 CS 536 Spring 2008 13 Ambitious “optimizations” were Compilers Enable used to produce efficient Programming Languages machine code, which was vital for early computers with quite Programming languages are limited capabilities. used for much more than “ordinary” computation. Efficient use of machine • TeX and LaTeX use compilers to translate text and formatting resources is still an essential commands into intricate requirement for modern typesetting commands. compilers. • Postscript, generated by text- formatters like LaTeX, Word, and FrameMaker, is really a programming language.
    [Show full text]
  • (URMD) Grad Cohort Workshop
    MARCH 16-17, 2018 SAN DIEGO GRAD Cohort UnderrepresentedURMD Minorities & Persons with Disabilities 2018 www.cra.org Dear Grad Cohort Participant, We welcome you to the 2018 CRA Grad Cohort Workshop for Underrepresented Minorities + Persons with Disabilities 2018 (URMD)! The next few days are filled with sessions where 25 senior computing researchers and professionals will be sharing their strategies and experiences to help increase GradCohort your graduate school and career success. There will also be plenty of opportunities to meet and network with these successful researchers as well as with graduate students from other universities. We hope that you will take the utmost advantage of this unique experience by actively participating in discussions, developing peer networks, and building mentoring relationships. Since this is the inaugural URMD Grad Cohort Workshop, we are especially interested in hearing your feedback about the program and the experience. Please take time to complete the evaluation form provided after the workshop. We want to learn what you liked and did not like, as well as any suggestions you might have for improving the event in subsequent years. The 2018 CRA-URMD Workshop is made possible through generous contributions by the Computing Research Association, National Science Foundation, AccessComputing, Whova, Google and Association for Computing Machinery. Please join us in thanking them for their kind support. We hope that you take home many new insights and connections from this workshop to help you succeed in
    [Show full text]
  • Entrepreneurship Opportunities & Skills
    Entrepreneurship Opportunities & Skills Kunle Olukotun Stanford University 2019 CRA URMD Grad Cohort Workshop Kunle Olukotun • Professor of EE and CS at Stanford since 1992 – Cadence Design endowed chair • Computer architecture and parallel computing • Pioneer in CMP (multicore) processor design – Stanford Hydra project • Parallel programming for all programmers – Director of Pervasive Parallelism Lab (PPL) – High-performance Domain Specific Languages (DSLs) • Data Analytics for What’s Next (DAWN) – Democratizing machine learning Academic Research and Startups • When you can’t find an industrial partner for your ideas make one • Technology transfer by PhD – Understand the initial market for your product (technology) – What is your unfair advantage – More robust technology than research prototypes – Cost of schedule slip is much worse – You don’t have much time for research at a start-up • Pick your team wisely – Technical team (lab partners?) – Management team (who is making decisions) – Cap table • Funding issues – Investors (smart vs. dumb) – Angels vs Venture Capital firms Startup Pros/Cons Pros Cons • Don’t have to convince existing company to change • Have to convince investors course (until exit) (repeatedly) • Have to build a whole company, not just a development team • Finance, sales, marketing, … • Limited resources • Impatient capital Afara WebSystems • Founded in 1999 – Height of internet boom – Large web sites running out of power and space – Goal: Revolutionize internet data centers (multi-B $ market) – Goal: Approach: 10x
    [Show full text]