C++ is a general-purpose programming language, developed by Bjarne Stroustrup as an extension of the C language, or "C with Classes". It has imperative, object-oriented and generic programming features, while providing facilities for low-level memory manipulation, it is always implemented as a compiled language, many vendors provide C++ compilers, including the Free Software Foundation, Intel, IBM, so it is available on many platforms. C++ was designed with a bias toward system programming and embedded, resource-constrained software and large systems, with performance and flexibility of use as its design highlights. C++ has been found useful in many other contexts, with key strengths being software infrastructure and resource-constrained applications, including desktop applications and performance-critical applications. C++ is standardized by the International Organization for Standardization, with the latest standard version ratified and published by ISO in December 2017 as ISO/IEC 14882:2017.
The C++ programming language was standardized in 1998 as ISO/IEC 14882:1998, amended by the C++03, C++11 and C++14 standards. The current C++ 17 standard supersedes these with an enlarged standard library. Before the initial standardization in 1998, C++ was developed by Danish computer scientist Bjarne Stroustrup at Bell Labs since 1979 as an extension of the C language. C++20 is the next planned standard, keeping with the current trend of a new version every three years. In 1979, Bjarne Stroustrup, a Danish computer scientist, began work on "C with Classes", the predecessor to C++; the motivation for creating a new language originated from Stroustrup's experience in programming for his Ph. D. thesis. Stroustrup found that Simula had features that were helpful for large software development, but the language was too slow for practical use, while BCPL was fast but too low-level to be suitable for large software development; when Stroustrup started working in AT&T Bell Labs, he had the problem of analyzing the UNIX kernel with respect to distributed computing.
Remembering his Ph. D. experience, Stroustrup set out to enhance the C language with Simula-like features. C was chosen because it was general-purpose, fast and used; as well as C and Simula's influences, other languages influenced C++, including ALGOL 68, Ada, CLU and ML. Stroustrup's "C with Classes" added features to the C compiler, including classes, derived classes, strong typing and default arguments. In 1983, "C with Classes" was renamed to "C++", adding new features that included virtual functions, function name and operator overloading, constants, type-safe free-store memory allocation, improved type checking, BCPL style single-line comments with two forward slashes. Furthermore, it included the development of a standalone compiler for Cfront. In 1985, the first edition of The C++ Programming Language was released, which became the definitive reference for the language, as there was not yet an official standard; the first commercial implementation of C++ was released in October of the same year.
In 1989, C++ 2.0 was released, followed by the updated second edition of The C++ Programming Language in 1991. New features in 2.0 included multiple inheritance, abstract classes, static member functions, const member functions, protected members. In 1990, The Annotated C++ Reference Manual was published; this work became the basis for the future standard. Feature additions included templates, namespaces, new casts, a boolean type. After the 2.0 update, C++ evolved slowly until, in 2011, the C++11 standard was released, adding numerous new features, enlarging the standard library further, providing more facilities to C++ programmers. After a minor C++14 update released in December 2014, various new additions were introduced in C++17, further changes planned for 2020; as of 2017, C++ remains the third most popular programming language, behind Java and C. On January 3, 2018, Stroustrup was announced as the 2018 winner of the Charles Stark Draper Prize for Engineering, "for conceptualizing and developing the C++ programming language".
According to Stroustrup: "the name signifies the evolutionary nature of the changes from C". This name is credited to Rick Mascitti and was first used in December 1983; when Mascitti was questioned informally in 1992 about the naming, he indicated that it was given in a tongue-in-cheek spirit. The name comes from C's ++ operator and a common naming convention of using "+" to indicate an enhanced computer program. During C++'s development period, the language had been referred to as "new C" and "C with Classes" before acquiring its final name. Throughout C++'s life, its development and evolution has been guided by a set of principles: It must be driven by actual problems and its features should be useful in real world programs; every feature should be implementable. Programmers should be free to pick their own programming style, that style should be supported by C++. Allowing a useful feature is more important than preventing every possible misuse of C++, it should provide facilities for organising programs into separate, well-defined parts, provide facilities for combining separately developed parts.
No implicit violations of the type system (but allow explicit violations.
ColdFusion is most used for data-driven websites or intranets, but can be used to generate remote services such as REST services, websockets, SOAP web services or Flash remoting. It is well-suited as the server-side technology to the client-side ajax. ColdFusion can handle asynchronous events such as SMS and instant messaging via its gateway interface, available in ColdFusion MX 7 Enterprise Edition. ColdFusion provides a number of additional features out of the box. Main features include: Simplified database access Client and server cache management Client-side code generation for form widgets and validation Conversion from HTML to PDF Data retrieval from common enterprise systems such as Active Directory, LDAP, SMTP, POP, HTTP, FTP, Microsoft Exchange Server and common data formats such as RSS and Atom File indexing and searching service based on Apache Solr GUI administration Server, client and request scopes XML parsing, querying and transformation Server clustering Task scheduling Graphing and reporting Simplified file manipulation including raster graphics and zip archives Simplified web service implementation Other implementations of CFML offer similar or enhanced functionality, such as running in a.
NET environment or image manipulation. The engine was written in C and featured, among other things, a built-in scripting language, plugin modules written in Java, a syntax similar to HTML; the equivalent to an HTML element, a ColdFusion tag begins with the letters "CF" followed by a name, indicative of what the tag is interpreted to, in HTML. E.g. <cfoutput> to begin the output of variables or other content. In addition to CFScript and plugins, CFStudio provided a design platform with a WYSIWYG display. In addition to ColdFusion, CFStudio supports syntax in other languages popular for backend programming, such as Perl. In addition to making backend functionality available to the non-programmer, integrated with the Apache Web Server and with Internet Information Services. All versions of ColdFusion prior to 6.0 were written using Microsoft Visual C++. This meant that ColdFusion was limited to running on Microsoft Windows, although Allaire did port ColdFusion to Sun Solaris starting with version 3.1.
The Allaire company was sold to Macromedia Macromedia was sold to Adobe. Earlier versions were not as robust as the versions available from version 4.0 forward. With the release of ColdFusion MX 6.0, the engine had been re-written in Java and supported its own runtime environment, replaced through its configuration options with the runtime environment from Sun. Version 6.1 included the ability to debug Shockwave Flash. 1995-July-02: Allaire Cold Fusion version 1.0 1996: Allaire Cold Fusion version 1.5 1996-November: Allaire Cold Fusion version 2.0 1997-June: Allaire Cold Fusion version 3.0 1998-January: Allaire Cold Fusion version 3.1 1998-November: Allaire ColdFusion version 4.0 1999-November: Allaire ColdFusion version 4.5 2001-June: Macromedia ColdFusion version 5.0 2002-May: Macromedia ColdFusion MX version 6.0, Updater 1, Updater 2, Updater 3 2003-July: Macromedia ColdFusion MX version 6.1, hot fix, Updater 1 2005-February-07: Macromedia ColdFusion MX 7 2005-September-27: Macromedia ColdFusion MX 7.0.1 2006-June-28: Macromedia ColdFusion MX 7.0.2 2007-July-30: Adobe ColdFusion 8 2008-April-03: Adobe ColdFusion 8.0.1 2009-October-05: Adobe ColdFusion 9 2010-July-13: Adobe ColdFusion 9.0.1 2012-May-15: Adobe ColdFusion 10 2012-May-31: Adobe ColdFusion 9.0.2 2012-August-31: Adobe ColdFusion 10 Update 1 2012-September-11: Adobe ColdFusion 10 Update 2 2012-October-16: Adobe ColdFusion 10 Update 3 (build 10,0,3
Test-driven development is a software development process that relies on the repetition of a short development cycle: requirements are turned into specific test cases the software is improved to pass the new tests, only. This is opposed to software development that allows software to be added, not proven to meet requirements. American software engineer Kent Beck, credited with having developed or "rediscovered" the technique, stated in 2003 that TDD encourages simple designs and inspires confidence. Test-driven development is related to the test-first programming concepts of extreme programming, begun in 1999, but more has created more general interest in its own right. Programmers apply the concept to improving and debugging legacy code developed with older techniques; the following sequence is based on the book Test-Driven Development by Example: 1. Add a test In test-driven development, each new feature begins with writing a test. Write a test that defines a function or improvements of a function, which should be succinct.
To write a test, the developer must understand the feature's specification and requirements. The developer can accomplish this through use cases and user stories to cover the requirements and exception conditions, can write the test in whatever testing framework is appropriate to the software environment, it could be a modified version of an existing test. This is a differentiating feature of test-driven development versus writing unit tests after the code is written: it makes the developer focus on the requirements before writing the code, a subtle but important difference. 2. Run all tests and see if the new test fails This validates that the test harness is working shows that the new test does not pass without requiring new code because the required behavior exists, it rules out the possibility that the new test is flawed and will always pass; the new test should fail for the expected reason. This step increases the developer's confidence in the new test. 3. Write the code The next step is to write some code that causes the test to pass.
The new code written at this stage is not perfect and may, for example, pass the test in an inelegant way. That is acceptable because it will be improved and honed in Step 5. At this point, the only purpose of the written code is to pass the test; the programmer must not write code, beyond the functionality that the test checks. 4. Run tests If all test cases now pass, the programmer can be confident that the new code meets the test requirements, does not break or degrade any existing features. If they do not, the new code must be adjusted. 5. Refactor code The growing code base must be cleaned up during test-driven development. New code can be moved from where it was convenient for passing a test to where it more logically belongs. Duplication must be removed. Object, module and method names should represent their current purpose and use, as extra functionality is added; as features are added, method bodies can get other objects larger. They benefit from being split and their parts named to improve readability and maintainability, which will be valuable in the software lifecycle.
Inheritance hierarchies may be rearranged to be more logical and helpful, to benefit from recognized design patterns. There are general guidelines for refactoring and for creating clean code. By continually re-running the test cases throughout each refactoring phase, the developer can be confident that process is not altering any existing functionality; the concept of removing duplication is an important aspect of any software design. In this case, however, it applies to the removal of any duplication between the test code and the production code—for example magic numbers or strings repeated in both to make the test pass in Step 3. Repeat Starting with another new test, the cycle is repeated to push forward the functionality; the size of the steps should always be small, with as few as 1 to 10 edits between each test run. If new code does not satisfy a new test, or other tests fail unexpectedly, the programmer should undo or revert in preference to excessive debugging. Continuous integration helps by providing revertible checkpoints.
When using external libraries it is important not to make increments that are so small as to be merely testing the library itself, unless there is some reason to believe that the library is buggy or is not sufficiently feature-complete to serve all the needs of the software under development. There are various aspects to using test-driven development, for example the principles of "keep it simple, stupid" and "You aren't gonna need it". By focusing on writing only the code necessary to pass tests, designs can be cleaner and clearer than is achieved by other methods. In Test-Driven Development by Example, Kent Beck suggests the principle "Fake it till you make it". To achieve some advanced design concept such as a design pattern, tests are written that generate that design; the code may remain simpler than the target pattern, but still pass all required tests. This can be unsettling at first but it allows the developer to focus only on what is important. Writing the tests first: The tests should be written before the functionality, to be tested.
This has been claimed to have many benefits. It helps ensure that the application is written for testability, as the developers must consider how to test the application from the outset rather than adding it later, it ensures that tests for every feature get written. Additionally, writing the tests first leads to a deeper and earlier understanding of the product requirements, ensures the effectiveness of the
PHP: Hypertext Preprocessor is a general-purpose programming language designed for web development. It was created by Rasmus Lerdorf in 1994. PHP stood for Personal Home Page, but it now stands for the recursive initialism PHP: Hypertext Preprocessor. PHP code may be executed with a command line interface, embedded into HTML code, or it can be used in combination with various web template systems, web content management systems, web frameworks. PHP code is processed by a PHP interpreter implemented as a module in a web server or as a Common Gateway Interface executable; the web server combines the results of the interpreted and executed PHP code, which may be any type of data, including images, with the generated web page. PHP can be used for many programming tasks outside of the web context, such as standalone graphical applications and robotic drone control; the standard PHP interpreter, powered by the Zend Engine, is free software released under the PHP License. PHP has been ported and can be deployed on most web servers on every operating system and platform, free of charge.
The PHP language evolved without a written formal specification or standard until 2014, with the original implementation acting as the de facto standard which other implementations aimed to follow. Since 2014, work has gone on to create a formal PHP specification. PHP development began in 1994 when Rasmus Lerdorf wrote several Common Gateway Interface programs in C, which he used to maintain his personal homepage, he extended them to work with web forms and to communicate with databases, called this implementation "Personal Home Page/Forms Interpreter" or PHP/FI. PHP/FI could be used to build dynamic web applications. To accelerate bug reporting and improve the code, Lerdorf announced the release of PHP/FI as "Personal Home Page Tools version 1.0" on the Usenet discussion group comp.infosystems.www.authoring.cgi on June 8, 1995. This release had the basic functionality that PHP has today; this included Perl-like variables, form handling, the ability to embed HTML. The syntax was simpler, more limited and less consistent.
Early PHP was not intended to be a new programming language, grew organically, with Lerdorf noting in retrospect: "I don't know how to stop it, there was never any intent to write a programming language I have no idea how to write a programming language, I just kept adding the next logical step on the way." A development team began to form and, after months of work and beta testing released PHP/FI 2 in November 1997. The fact that PHP was not designed, but instead was developed organically has led to inconsistent naming of functions and inconsistent ordering of their parameters. In some cases, the function names were chosen to match the lower-level libraries which PHP was "wrapping", while in some early versions of PHP the length of the function names was used internally as a hash function, so names were chosen to improve the distribution of hash values. Zeev Suraski and Andi Gutmans rewrote the parser in 1997 and formed the base of PHP 3, changing the language's name to the recursive acronym PHP: Hypertext Preprocessor.
Afterwards, public testing of PHP 3 began, the official launch came in June 1998. Suraski and Gutmans started a new rewrite of PHP's core, producing the Zend Engine in 1999, they founded Zend Technologies in Ramat Gan, Israel. On May 22, 2000, PHP 4, powered by the Zend Engine 1.0, was released. As of August 2008 this branch reached version 4.4.9. PHP 4 will any security updates be released. On July 14, 2004, PHP 5 was released, powered by the new Zend Engine II. PHP 5 included new features such as improved support for object-oriented programming, the PHP Data Objects extension, numerous performance enhancements. In 2008, PHP 5 became the only stable version under development. Late static binding had been missing from PHP and was added in version 5.3. Many high-profile open-source projects ceased to support PHP 4 in new code as of February 5, 2008, because of the GoPHP5 initiative, provided by a consortium of PHP developers promoting the transition from PHP 4 to PHP 5. Over time, PHP interpreters became available on most existing 32-bit and 64-bit operating systems, either by building them from the PHP source code, or by using pre-built binaries.
For PHP versions 5.3 and 5.4, the only available Microsoft Windows binary distributions were 32-bit x86 builds, requiring Windows 32-bit compatibility mode while using Internet Information Services on a 64-bit Windows platform. PHP version 5.5 made. Official security support for PHP 5.6 ended on 31 December 2018, but Debian 8.0 Jessie will extend support until June 2020. PHP received mixed reviews due to lacking native Unicode support at the core language level. In 2005, a project headed by Andrei Zmievski was initiated to bring native Unicode support throughout PHP, by embedding the International Components for Unicode library, representing text strings as UTF-16 internally. Since this would cause major changes both to the internals of the language and to user code, it was planned to release this as version 6.0 of the language, along with other major features in development. However, a shortage of developers who understood the necessary changes, performance problems arising from conversion to and from UTF-16, used in a web context, led to delays in the project.
As a result, a PHP 5.3 release was created in 2009, with many non-Unicode f
Delphi is an integrated development environment for rapid application development of desktop, mobile and console software, developed by Embarcadero Technologies. It is an event-driven language. Delphi's compilers use their own Object Pascal dialect of Pascal and generate native code for Microsoft Windows, macOS, iOS, Android and Linux. Since 2016, there have been new releases of Delphi every six months, with new platforms being added every second release. Delphi includes a code editor, a visual designer, an integrated debugger, a source code control component, support for third-party plugins; the code editor features Code Insight, Error Insight, refactoring. The visual forms designer has traditionally used Visual Component Library for native Windows development, but the FireMonkey platform was added for cross-platform development. Database support in Delphi is strong. A Delphi project of a million lines to compile in a few seconds – one benchmark gave 170,000 lines per second. Delphi was developed by Borland as a rapid application development tool for Windows as the successor of Turbo Pascal.
Delphi added full object-oriented programming to the existing language, since the language has grown to support generics and anonymous methods, native Component Object Model support. In 2006, Borland’s developer tools section was transferred from Borland to a wholly owned subsidiary known as CodeGear, sold to Embarcadero Technologies in 2008. In 2015, Embarcadero was purchased by Idera Software, but the Embarcadero mark was retained for the developer tools division. Delphi and its C++ counterpart, C++Builder, are interoperable, they share many core components, notably the IDE, VCL, much of the runtime library. In addition, they can be used jointly in a project. For example, C++Builder 6 and can consume Delphi source code and C++ in one project, while packages compiled with C++Builder can be used from within Delphi. In 2007, the products were released jointly as RAD Studio, a shared host for Delphi and C++Builder, which can be purchased with either or both. Delphi supports rapid application development.
Among the features supporting RAD are the visual designer. Delphi uses, it supports native cross-compilation. Its visual designer has traditionally used Visual Component Library for RAD. To better support development for Microsoft Windows and interoperate with code developed with other software development tools, Delphi supports independent interfaces of Component Object Model with reference counted class implementations, support for many third-party components. Interface implementations can be delegated to properties of classes. Message handlers are implemented by tagging a method of a class with the integer constant of the message to handle. Database connectivity is extensively supported through the many VCL database-aware and database access components. Versions have included upgraded and enhanced runtime library routines provided by the community group FastCode, established in 2003. Delphi is a typed high-level programming language, intended to be easy to use and based on the earlier Object Pascal language.
Pascal was developed as a general-purpose language "suitable for expressing the fundamental constructs known at the time in a concise and logical way", "its implementation was to be efficient and competitive with existing FORTRAN compilers" but without low-level programming facilities or access to hardware. Turbo Pascal and its descendants, including Delphi, support access to hardware and low-level programming, with the facility to incorporate code written in assembly language and other languages. Delphi's object orientation features only class- and interface-based polymorphism. Metaclasses are first class objects. Objects are references to the objects, which Delphi implicitly de-references, so there is no need to manually allocate memory for pointers to objects or use similar techniques that some other languages need. There are dedicated reference-counted string types, null-terminated strings. Strings can be concatenated by using the'+' operator, rather than using functions. For dedicated string types Delphi handles memory management without programmer intervention.
Since Borland Developer Studio 2006 there are functions to locate memory leaks. Delphi includes an integrated IDE; the Delphi products all ship including most of its source code. Third-party components and tools to enhance the IDE or for other Delphi related development tasks are available, some free of charge; the IDE includes a GUI for localization and translation of created programs that may be deployed to a translator. The VCL framework maintains a high level of source compatibility between versions, which simplifies updating existing source code to a newer Delphi version. Third-party libraries may need updates from the vendor but, if source code is supplied, recompilation with the newer version may be sufficient; the VCL was an early adopter of dependency inversion of control. With class helpers new functionality can be introduced to core RTL and VCL classes without changing the original source code of the RTL or VCL; the compiler is single pass. It can optionally compile to a single executable.
Delphi can generate standard DLLs, ActiveX DLLs, COM automation serv
Fortran is a general-purpose, compiled imperative programming language, suited to numeric computation and scientific computing. Developed by IBM in the 1950s for scientific and engineering applications, FORTRAN came to dominate this area of programming early on and has been in continuous use for over half a century in computationally intensive areas such as numerical weather prediction, finite element analysis, computational fluid dynamics, computational physics and computational chemistry, it is a popular language for high-performance computing and is used for programs that benchmark and rank the world's fastest supercomputers. Fortran encompasses a lineage of versions, each of which evolved to add extensions to the language while retaining compatibility with prior versions. Successive versions have added support for structured programming and processing of character-based data, array programming, modular programming and generic programming, high performance Fortran, object-oriented programming and concurrent programming.
Fortran's design was the basis for many other programming languages. Among the better known is BASIC, based on FORTRAN II with a number of syntax cleanups, notably better logical structures, other changes to more work in an interactive environment; the names of earlier versions of the language through FORTRAN 77 were conventionally spelled in all-capitals. The capitalization has been dropped in referring to newer versions beginning with Fortran 90; the official language standards now refer to the language as "Fortran" rather than all-caps "FORTRAN". In late 1953, John W. Backus submitted a proposal to his superiors at IBM to develop a more practical alternative to assembly language for programming their IBM 704 mainframe computer. Backus' historic FORTRAN team consisted of programmers Richard Goldberg, Sheldon F. Best, Harlan Herrick, Peter Sheridan, Roy Nutt, Robert Nelson, Irving Ziller, Lois Haibt, David Sayre, its concepts included easier entry of equations into a computer, an idea developed by J. Halcombe Laning and demonstrated in the Laning and Zierler system of 1952.
A draft specification for The IBM Mathematical Formula Translating System was completed by November 1954. The first manual for FORTRAN appeared in October 1956, with the first FORTRAN compiler delivered in April 1957; this was the first optimizing compiler, because customers were reluctant to use a high-level programming language unless its compiler could generate code with performance comparable to that of hand-coded assembly language. While the community was skeptical that this new method could outperform hand-coding, it reduced the number of programming statements necessary to operate a machine by a factor of 20, gained acceptance. John Backus said during a 1979 interview with Think, the IBM employee magazine, "Much of my work has come from being lazy. I didn't like writing programs, so, when I was working on the IBM 701, writing programs for computing missile trajectories, I started work on a programming system to make it easier to write programs."The language was adopted by scientists for writing numerically intensive programs, which encouraged compiler writers to produce compilers that could generate faster and more efficient code.
The inclusion of a complex number data type in the language made Fortran suited to technical applications such as electrical engineering. By 1960, versions of FORTRAN were available for the IBM 709, 650, 1620, 7090 computers; the increasing popularity of FORTRAN spurred competing computer manufacturers to provide FORTRAN compilers for their machines, so that by 1963 over 40 FORTRAN compilers existed. For these reasons, FORTRAN is considered to be the first used programming language supported across a variety of computer architectures; the development of Fortran paralleled the early evolution of compiler technology, many advances in the theory and design of compilers were motivated by the need to generate efficient code for Fortran programs. The initial release of FORTRAN for the IBM 704 contained 32 statements, including: DIMENSION and EQUIVALENCE statements Assignment statements Three-way arithmetic IF statement, which passed control to one of three locations in the program depending on whether the result of the arithmetic statement was negative, zero, or positive IF statements for checking exceptions.
The arithmetic IF statement was reminiscent of a three-way comparison instruction available on the 704. The statement provided the only way to compare numbers – by testing their difference, with an attendant risk of overflow; this deficiency was overcome by "logical" facilities introduced in FORTRAN IV. The FREQUENCY statement was used to give branch probabilities for the three branch cases of the arithmetic IF statement; the first FORTRAN compiler used this weighting to perform at compile time a Monte Carlo simulation of the generated code, the results of which were used to optimize the
Kent Beck is an American software engineer and the creator of extreme programming, a software development methodology that eschews rigid formal specification for a collaborative and iterative design process. Beck was one of the 17 original signatories of the Agile Manifesto, the founding document for agile software development. Extreme and Agile methods are associated with Test-Driven Development, of which Beck is the leading proponent. Beck pioneered software design patterns, as well as the commercial application of Smalltalk, he wrote the SUnit unit testing framework for Smalltalk, which spawned the xUnit series of frameworks, notably JUnit for Java, which Beck wrote with Erich Gamma. Beck popularized CRC cards with the inventor of the wiki, he lives in San Francisco and worked at social media company Facebook. Beck attended the University of Oregon between 1979 and 1987, receiving B. S. and M. S. degrees in computer and information science. In 1996 Beck was hired to work on the Chrysler Comprehensive Compensation System.
Beck in turn brought in Ron Jeffries. In March 1996 the development team estimated the system would be ready to go into production around one year later. In 1997 the development team adopted a way of working, now formalized as extreme programming; the one-year delivery target was nearly achieved, with actual delivery being only a couple of months late. 1996. Kent Beck's Guide to Better Smalltalk: A Sorted Collection. Cambridge University Press. 1997. Smalltalk Best Practice Patterns. Prentice Hall. 1999. Extreme Programming Explained: Embrace Change. Addison-Wesley. Winner of the Jolt Productivity Award. 2000. Planning Extreme Programming. With Martin Fowler. Addison-Wesley. 2002. Test-Driven Development: By Example. Addison-Wesley. Winner of the Jolt Productivity Award. Beck's concept of test-driven development centers on two basic rules: Never write a single line of code unless you have a failing automated test. Eliminate duplication; the book illustrates the use of unit testing as part of the methodology, including examples in Java and Python.
One section includes using test-driven development to develop a unit testing framework. 2003. Contributing to Eclipse: Principles and Plugins. With Erich Gamma. Addison-Wesley. 2004. JUnit Pocket Guide. O'Reilly. 2004. Extreme Programming Explained: Embrace Change, 2nd Edition. With Cynthia Andres. Addison-Wesley. Rewritten. 2008. Implementation Patterns. Addison-Wesley. 1987. "Using Pattern Languages for Object-Oriented Programs". With Ward Cunningham. OOPSLA'87. 1989. "A Laboratory For Teaching Object-Oriented Thinking". With Ward Cunningham. OOPSLA'89. 1989. "Simple Smalltalk Testing: With Patterns". SUnit framework, origin of xUnit frameworks. KentBeck on the WikiWikiWeb Sample chapter of Kent's book, IMPLEMENTATION PATTERNS TalkWare Podcast interview with Kent Beck FLOSS Weekly interview with Kent Beck Kent Beck's Notes at Facebook Kent Beck on unit testing Being Human Podcast - A conversation with Kent Beck