Frank Lloyd Wright's Hollyhock House: The Story of an LA Icon

Table Of Content

• An Insider’s Tour of Frank Lloyd Wright’s Hollyhock House
• Timeline
• Who was Aline Barnsdall?
• Barnsdall Junior Arts Center & Barnsdall Junior Arts Center Gallery
• Barnsdall Arts Center

Barnsdall Art Park on Olive Hill in Hollywood, California is now owned and run by the City of Los Angeles. The City of Los Angeles is home to many architectural treasures, none more intriguing than Hollyhock House. The Department of Cultural Affairs manages this and four other entities in Barnsdall Art Park, but the focus of this photo journey is on Hollyhock House. Built between 1919 and 1921, the house realized by Wright for Louise Aline Barnsdall is an architectural experiment among landscaped gardens, hardscaped pools, and galleries of art on Olive Hill.

An Insider’s Tour of Frank Lloyd Wright’s Hollyhock House

Water is meant to flow from a pool in the courtyard through a tunnel to this inside moat, and out again to a fountain. Disillusioned by the costs of construction and maintenance, Barnsdall donated the house to the city of Los Angeles in 1927[8] under the stipulation that a fifteen-year lease be given to the California Art Club for its headquarters. The club was there until 1942 when the house was almost demolished.[9] The house has been used as an art gallery and as a United Service Organizations (USO) facility over the years. Beginning in 1974, the city sponsored a series of restorations, but the structure was damaged in the 1994 Northridge earthquake.

Timeline

He designed it for Aline Barnsdall, a wealthy iconoclast and patron of the arts (learn more about her here). Barnsdall envisioned the house as the centerpiece of an artists’ colony on Olive Hill in the neighborhood of Los Feliz. Hollyhock House was designed by America’s most important 20th-century architect, Frank Lloyd Wright. Aline Barnsdall was also a philanthropist and in 1927 gave the house and the surrounding twelve acres atop Olive Hill (now Barnsdall Park) to the City of Los Angeles as a memorial to her father Theodore. With project delays and cost overruns, he then left the project only partially realized. Within a few years, Barnsdall began to consider gifting the house and surrounding parklands to the City of Los Angeles.

Who was Aline Barnsdall?

100 years after Frank Lloyd Wright finished construction on Aline Barnsdall’s Residence A guest house, the City of Los Angeles has concluded phase I restoration of this landmark structure. The first video provides an overview from the project team, discussing the home’s significance, what’s been done in phase I, and what work is still to come. Barnsdall bought Olive Hill in 1919 from the widow of the man who had planted the olive trees. Wright eventually came up with grand plans that suited Barnsdall's theatricality, although she and her daughter never lived in the house that Wright built.

In 2007, the City and Project Restore, a public-private partnership, began planning a project to address structural needs and restoration. In 2010, the project team began four years of work to repair and prevent water damage, seismically strengthen the house, restore historic elements, and reverse past alterations. Built between 1919 and 1921, Hollyhock House was the first Los Angeles commission for the legendary architect Frank Lloyd Wright.

Oil heiress Aline Barnsdall commissioned the house as the centerpiece of a cultural arts complex on Olive Hill, which was to include a major theatre, cinema, artist residences, and commercial shops. For Hollyhock House, her personal residence, Barnsdall asked Wright to incorporate her favorite flower, the hollyhock, into the design. In 1927, Barnsdall donated the house and the surrounding 12 acres (now Barnsdall Park) to the City of Los Angeles. Today, Hollyhock House is owned and operated by the Department of Cultural Affairs (DCA). Yet it was renovated several times, had long suffered from water intrusion, and was damaged in the 1994 Northridge earthquake.

A passionate supporter of the arts, she was a stage producer—earning critical acclaim for her avante-garde productions for children and adults alike in Chicago, New York, and Los Angeles (while awaiting a Wright-designed theater that never came). In 1919, she purchased Olive Hill, a 36-acre mount on Hollywood’s eastern edge and far north of downtown Los Angeles. With the site secured, the commission grew to include plans for the theater, a cinema, artist residences, commercial shops, two guest houses, and a residence for Barnsdall.

Time travel to these historic LA homes - Daily Trojan Online

Time travel to these historic LA homes.

Posted: Wed, 16 Aug 2023 07:00:00 GMT [source]

Friends of Hollyhock House (FOHH)

For Hollyhock House, Barnsdall asked Wright to incorporate her favorite flower, the hollyhock, into the home’s design. As with many of Wright's residences, Hollyhock House has an "introverted" exterior with windows that seem hidden from the outside, and is not easy to decode from the outside. The house is arranged around a central courtyard with one side open to form a kind of theatrical stage (never used as such), and a complex system of split levels, steps and roof terraces around that courtyard.

Hollyhock House, One of Eight Frank Lloyd Wright Buildings, Inscribed on UNESCO World Heritage List - City of Los Angeles (.gov)

Hollyhock House, One of Eight Frank Lloyd Wright Buildings, Inscribed on UNESCO World Heritage List.

Posted: Fri, 09 Aug 2019 07:00:00 GMT [source]

She never questioned the beauty or significance of Wright’s work on Olive Hill, but with early leaks and no theater to speak of, the house had lost its luster for Barnsdall. She did, however, reengage with Wright on numerous occasions after 1921, enlisting him to design a school house for the property as well as preliminary plans for another residence in Beverly Hills; neither were realized. In 1915, Aline Barnsdall, an oil heiress, first approached Frank Lloyd Wright not to build a house but a theater.

A philosophy of software design John Ousterhout

Table Of Content

• Agile does not encourage strategic programming
• Define Errors Out of Existence
• Chapter 19 — Software Trends
• Things that make code more obvious

In some examples, the author recommends that some domain concepts are explained in the comments, in case the reader isn’t familiar with them. However, for well-known domain concepts, the reader will almost certainly already be familiar with those concepts. Even if they are not, the comments aren’t the right place to explain them. If the lower index is below zero, or the higher index is beyond the string length, an IndexOutOfBoundsException is thrown. This forces the caller to handle these cases before calling substring.

John Ousterhout Discusses a Philosophy of Software Design - Adafruit Blog

John Ousterhout Discusses a Philosophy of Software Design.

Posted: Wed, 03 Oct 2018 07:00:00 GMT [source]

Agile does not encourage strategic programming

To add to this, we haven't completely identified all of the issues we will confront. In essence, we still have to discover the Unknown Unknowns as we cautiously proceed. There are also a few weaker chapters towards the end of the book, for example Code Should Be Obvious and Software Trends. Code Complete has a lot more to say about names, and does it better. However, I really liked the story of how a too generic variable name (block) caused a bug that took six months to find. In a lot of places, the author uses comments and documentation interchangeably.

Define Errors Out of Existence

We need more resources to remind us not overcomplicate software architecture. It will become complicated enough, module after module, layer after layer. The author argues that if your code throws an exception, you force all callers of that code to know how to handle this exception. Yet, in many cases, callers don’t know what to do about the exception which is thrown. He says we should define our functionality so we never need to throw an exception.

Chapter 19 — Software Trends

While event-driven programming is certainly more complex, due to no clear flow of control, in real-world scenarios, this is a necessity. Both in the case of distributed systems, as well as multi-threaded environments, there is no other option. John's suggestion to add a comment for event handlers doesn't cut it in my book. Instead, monitoring errors, alerting (for backend code) and logging, uploading, and analyzing logs (for client-side applications) is one way to stay on top of the system working correctly at all times. Much of modern programming, from messaging services to frameworks like Fx is moving towards an asynchronous model, where dealing with this complexity is part of the job. A strong stance against exceptions (Chapter 10) was an interesting read.

The book doesn’t focus on a specific programming language or framework but rather presents general software design ideas. "Exception handling is one of the worst sources of complexity in softwaresystems". They can leak abstraction details upwards, making for a more shallowabstraction. Programmers are often taught that they need to handle exceptionalcases, leading for an over-defensive programming style. One pitfall is that complexity in software development is incremental.

"If you reduce the number of methods in an API without reducing its overallcapabilities, then you are probably creating more general-purpose methods." An abstraction is asimplified view of an entity which omits unimportant details, making it easierfor us to think about and manipulate complex things. It is more important for a module to have a simple interface than a simple implementation. That being said, we have to be wary of Classitis a term I have come to appreciate and can relate too, as I have worked on many software systems in the past that actually have this issue.

Deep modules

It's more important for a module to have a simple interface than a simpleimplementation. If you have complexity that is closely related to your module'sfunctionality, you should consider pulling that complexity into the module'simplementation. Ousterhout's most often-used approach to this problem is to introduce a contextobject, which stores the application's global state - anything that wouldotherwise be a pass-through or global variable. They are not an ideal solutionbecause they have a lot of the disadvantages of global variables, but they canreduce the complexity of a method's signature.

Other materials, books, articles, etc.

Ousterhoutdiscusses the different types and causes of complexity, and then varioussoftware design considerations and their relationship to complexity - patterns,antipatterns, questions to ask, etc. While the book does a good job covering architecture concepts when writing code, there are several areas that it does not touch on. Most of these are outside the scope of the software design course itself. The importance of good and simple naming (Chapter 14) mirror my experience on how simple names often mean simple functionality. Complex names - or difficulty to name something - is usually a code or architecture smell.

OnePlus Nord 3 5G Interview: Kinder Liu On The Philosophy Of Nord - Forbes

OnePlus Nord 3 5G Interview: Kinder Liu On The Philosophy Of Nord.

Posted: Tue, 04 Jul 2023 07:00:00 GMT [source]

🔴 Software Design Red Flags

Tradeoffs when combining or separating implementations within modules or interfaces (Chapter 9) is an interesting debate that I don't know of a single best answer. We share this view with John, who also agrees the best solution will be context-dependent. John collects a few rules of thumbs he suggests to use when deciding to combine or separate. Combine when it makes for a simpler interface, to reduce duplication or when implementations share data/information. Software design is a critical aspect of developing reliable and high-performing software applications.

It involves the process of conceptualizing, planning, and defining the structure, architecture, and functionality of a software system. To create software that is not only functional but also maintainable and scalable, developers embrace a philosophy of software design. This philosophy encompasses principles, strategies, and best practices that guide developers in crafting well-designed, robust, and efficient software solutions.

If you're interested in whether to read this book, my recommendation is that you probably should, for a few reasons I list in my conclusion. When you’re performing a code review on a class, smell around for special purpose code mixed with general purpose code. This mixture represents an opportunity to split off the general purpose code into something more reusable. But yours is a great review and a valuable service to the IT community that increasingly finds itself facing Technical Debt to the point of bankruptcy. Like reusing a common class, consistent naming lessens cognitive load by enabling readers to quickly draw assumptions when they see the name in a different context because they have already seen it in one.

You can apply the ideas in this book to minimize the complexity of large software systems so that you can write software more quickly and cheaply. For people who have less experience in software development, the remaining of the book will also be practical. The parts on writing comments before coding, and comments complimenting the code are decent strategies to start with. Those with more experience under their belt my disagree with some of the recommendations.

A Philosophy of Software Design John K Ousterhout

Table Of Content

• Chapter 9 — Better Together Or Better Apart?
• Test-driven development
• Deep modules
• Chapter 6 — General-Purpose Modules are Deeper

This kind of decomposition has a different purpose to designingpublic interfaces, but sometimes get added to the public API of a class ormodule. The primary focus of the book is about attempting to eliminate or at least reduce complexity in software. This can be achieved by taking more time and consideration in the design and thinking about the implications of design. Related to the concept of deep modules is the advice to make them “somewhat general purpose”.

Chapter 9 — Better Together Or Better Apart?

You often throw an exception because you don’t know what to do in that case. But if you have trouble knowing what to do, chances are the caller also has trouble knowing what to do. If you can define your functionality such that it never needs to throw an exception, then you have reduced the complexity of the system. There are few books that discuss software design in a simple and approachable way, while leaving the reader novel and practical concepts to use. A Philosophy of Software Design is a standout and recommended read for this reason.

Test-driven development

However, it turns out that the most common use of unset was to clean up temporary state created by a previous operation. But it was hard to know how far the previous operation had progressed, so it was hard to know if a variable had been created or not. Thus you had to be prepared to handle exceptions from unset in a lot of places. It would have been much more useful, and simpler, if unset had been defined to mean that it ensures a variable with that name does not exist after it has been run, regardless of if it existed before or not. If your code throws an exception, you are forcing all callers of that code to be prepared to handle it if it happens.

Deep modules

Otherwise, you are better off implementing the system without that particular element. For example, a class can reduce complexity by encapsulating functionality so that users of the class needn’t be aware of it. Classitis may result in classes that are individually simple, but it increases the complexity of the overall system. Small classes don’t contribute much functionality, so there have to be a lot of them, each with its own interface.

Writing up, sharing, and debating design with other peers is a practice more and more common in tech companies. This includes both whiteboarding and presenting to a group of peers, as well as more formal RFC-like design processes. While it might be less applicable to the course John taught, it's a practice that comes with many benefits. These days, as shared editing and commenting tools are more common, with editors like Google Docs and O365.

However, in my opinion, the documentation of a system is not the sum of the comments. It is a separate document that describes how the system fits together. Extracting the JavaDoc comments from all the classes does not become the documentation. Nothing highlights which classes are most important, and what the overall structure is. The chapter on optimization starts by listing typical times taken by various operations such as network communication, I/O to storage (disk, flash), memory allocation and cache misses.

Chapter 6 — General-Purpose Modules are Deeper

It was one of the primary sources of making procedural/spaghetti code and the source of many unpredictable bugs. I agree with the author that we should write comments if we have to explain something tricky (such as an algorithm or something similar) or non-obvious (why, not how). In addition, the author mentions a famous API design antipattern involving overexposing internals, which later adds to an architecture debt. One way to make code more obvious to the reader is to have blank lines betweenparts that are logically separate, and maybe to preface the code block with animplementation comment. The overall complexity of a system can be determined by the complexity of eachpart, weighted by the fraction of time developers spend working on that part. Ifyou isolate complexity in a place where it will never be seen, then that'salmost as good as eliminating it entirely.

Technical debt and architecture debt also don't get much mention or discussion, which is in contrast to my day to day work. It would be nice to see a later version touch on these topics, as well. The book is an easy read, thanks to its short sections and good bolding. Most importantly, the book stays humble, does not try to convince, but offers perspectives backed by easy to follow examples.

It continues with the standard advice of always measuring instead of assuming. When optimizing, the biggest gains can usually be had by fundamental changes. For example by introducing a cache, or changing the algorithm or data structure. As a budding developer, using jQuery extensively taught me the importance of simple interfaces in driving adoption of your code. On page 68, the author mentions the GOTO command to eliminate duplication by refactoring the code so that we can escape from the nested code. This is a big surprise, as the GOTO command has been considered a terrible idea by most authors for decades now.

If the code is so complex, we need to comment on it; maybe we can rewrite it to be more straightforward and understandable. Most people use a tactical approach, where the goal is to make something work. However, the result is a bad design with a lot of tech complexity, which usually results in spaghetti code. Complexity is not a single line but many lines in a project, which we overlook as a whole. His recommendation is to take a strategic approach where the working code is not the only goal, but the goal should be great design, which simplifies development and minimizes complexity. It involves breaking down software systems into smaller, independent modules or components, each responsible for a specific functionality or feature.

What Is DevOps? - dummies - Dummies.com

What Is DevOps? - dummies.

Posted: Wed, 16 Aug 2023 07:00:00 GMT [source]

A singleshortcut or tactical decision that adds complexity won't have much impact, butsmall decisions can accumulate to dozens or hundreds of things that do have animpact. Then refactoring becomes a big task that you can't easily schedule withthe business, so you look for quick patches, and this creates yet morecomplexity, which requires more patches, and so forth. Ousterhout advocates for a strategic approach to software development, ratherthan a wholly tactical approach. This essentially just means ongoing, regularinvestment of some of your development time towards system design, rather thanjust working code. When building software systems, the core challenge is managingcomplexity.

Pass-through variables add complexity because they force intermediate methods tobe aware of their existence, even though the methods have no use for thevariables. Below are the notes I made on takeaways from the book and my thoughts on acouple of the ideas (minus some fun references to real code that I've workedon). I'm publishing the notes as it's a nice way for me to re-read them andretain the information. This doesn't cover all the content in the book, and it'spossible that I misrepresent the author in some of my paraphrasing. If you'reinterested in the content I definitely recommend buying a copy - it's notexpensive and it's an easy read. What makes it especially great from a software related book, is that there is really not a lot of code to read and for what there is, it is just to relay an idea.

Instead you can define it to return the characters of the string (if any) with index greater than or equal to beginIndex and less than endIndex. That way no exception needs to be thrown, which greatly simplifies the usage. Python does something similar when returning an empty result for out-of-range list slices. An example is when you have implemented a message protocol with a sender and a receiver.

Still, they all present interesting viewpoints, backed with examples. They also make for potentially sound advice to give, when mentoring less experienced engineers. Ousterhout argues that the best modules are those that provide powerfulfunctionality, but have a simple interface. He describes these as deep modules,in contrast to shallow modules, which have a complex interface but not muchfunctionality, thereby not hiding significant complexity. After that, you have to concentrate on speeding up the most commonly executed path. Currently maybe several method calls are used, but perhaps all the work could be done in a single method call.