If you will be programming in Java, these books will serve you incredibly well:

  * Effective Java
  * Java Concurrency in Practice
  * Head First Design Patterns

- Sapiens

- The Lord of the Rings

- Siddhartha

- Chaos: Making a New Science

- The Death Gate cycle books

- Neuromancer

- Head First Design Patterns

- Valis

- Dune

- The name of the rose

I'm sure there are more, but these are the ones off the top of my head.

It depends heavily on what stage of your career as a programmer you are.

I strongly suggest most junior programmers I work with to read Effective Java and Head First Design Patterns. To me, it's a great combination to help you write code that's easy to understand and maintain.

Sure, not only the GOF, but 5 volumes of POSA, Martin Fowler's POEAA, and reams of digested pattern books like Head First Design Patterns, etc. There's dozens.

Since you say you are a novice, I'd recommend Head First Design Patterns:

http://www.amazon.com/dp/0596007124

Do not jump in with the GoF Design Pattern book. :)

I've only read Head First Design Patterns but I'd also vouch - the examples were silly but I think did a great job.

The books listed in this article are great. Code Complete, Pragmatic Programmer, Head First Design Patterns, all great.

I would suggest reading Head first design pattern, apart from design patterns the book also explains how 'change' is inevitable in software development and how to design the software extensible and modular

Head First Design Patterns is awesome. I read a couple other Design Pattern books, but didn't really get it. I didn't want to buy a "Head First" book because it looked kind of silly, but this book has finally opened my eyes to what Design Patterns are about.

If you want a good alternative to the GoF book try Head First Design Patterns. I findit much more approachable and much more enjoyable to read.
http://www.amazon.com/Head-First-Design-Patterns-Freeman-ebo...

Two books I recommend

1) Head First Design Pattern

2) Effective Java (Joshua Bloch). The principles in this book can be applied to almost any programming language not just Java

It's midnight CST, and I finally saw one of my five books purchased ("Head First Design Patterns") show up. Hopefully the rest will follow...

I liked Head First Design Patterns. It's fun and covers most of GoF patterns (with a brief overview of leftovers). The examples (although fairly trivial) are in Java.

* The Pragmatic Programmer (Read this once every 6 months until it's obvious)

* Head first design patterns

* Agile Web Development with Rails

It's not obvious, but the rails book is a great introduction to test-driven development in general.

Some foundational stuff I usually recommend:
- algorithms and datastructures (princeton coursera course)
- functional programming will make you a better developer
- "head first design patterns" is a book that will get you to understand the heuristic of design patterns in OO fast

In addition to all the other patterns books mentioned, Head First Design Patterns is a great intro the subject. I think you will get more out of GoF if read this first.

For a novice coder I couldn't recommend Head First Design Patterns enough - the gang of four design patterns are a bit controversial these days but the way it steps you through and makes you think twice about how to organise things was really eye-opening for me back in the day.

I've read a couple and her books are amazingly good.
I especially liked Head First Design Patterns -- I've read 4-5 books on the subject, but the Head First examples are the ones that have stuck with me after all these years.

Her SCJP books were also exceptionally good/the gold standard as far as I remember.

>Head First series

Whilst the Head First series definitely has a childish tone the content provides a solid foundation for the various subjects in the series.

Head First Design Patterns is hands down the most approachable book. It makes the GoF look like a Latin textbook.

Head First Design Patterns by Eric Freeman
Design patterns by GoF
Code Complete by Steve McConnel

Yeah, I hated that book. I didn't really understand it. Then I read "Head First Design Patterns" and it clicked. I went back to the Gamma book and now it makes sense, but not as a first book on Design Patterns.

My top priority books:

    Software Requirements - Karl Wiegers

    Programming TypeScript - Boris Cherny

    Associate Cloud Engineer Study - Dan Sullivan

    Design Patterns - Gang of Four

    Refactoring - Kent Beck, Martin Fowler

    Programming Pearls - Jon Bentley

    Patterns of Enterprise Application Architecture - Martin Fowler

    The Pragmatic Programmer - David Thomas, Andrew Hunt

    CSS: The Definitive Guide - Eric A. Meyer, Estelle Weyl

    Working Effectively with Legacy Code - Michael Feathers

    Head First Design Patterns - Eric Freeman, Bert Bates

    Code Complete - Steve McConnell

    Peopleware - Tim Lister, Tom DeMarco

    Clean Code - Robert C. Martin

    The Clean Coder - Robert C. Martin

    Clean Architecture - Robert C. Martin

    Don't Make Me Think - Steve Krug

    Functional Design Patterns for Express.js - Jonathan Lee Martin

    The Surrender Experiment - Michael A. Singer

The best books I've ever read:

    Principles - Ray Dalio

    The Power of Now - Eckhart Tolle

    The Effective Executive - Peter F. Drucker

    Think and Grow Rich - Napoleon Hill

    Extreme Ownership - Jocko Willink, Leif Babin

    Influence - Robert B. Cialdini

    The Startup Way - Eric Ries

    The Lean Startup - Eric Ries

    12 Rules for Life - Jordan B. Peterson

    Measure What Matters - John Doerr, Larry Page

    The Fish That Ate the Whale - Rich Cohen

    The E-Myth Revisited - Michael E. Gerber

    The Score Takes Care of Itself - Bill Walsh, Steve Jamison, Craig Walsh

    Management - Peter F. Drucker

    Thinking in Systems - Donella H. Meadows

    Blue Ocean Strategy - W. Chan Kim, Renee Mauborgne

Thanks! I actually went through all the links in this thread and found quite a few books, specifically Head First Design Patterns + Head First Object Oriented Analysis & Design.

You succinctly described my plight, "knowing the syntax but not having a deep understanding" as well.

Personally I really liked "Head First: Design Patterns" because it's more about the overarching strategies (e.g. composition vs. inheritance) which design patterns are merely examples of. It was more of a top-down approach - I didn't realize memorize the patterns themselves, but internalized the justifications for them.

Good for you young jedi. I started coding around that age as well. I made the mistake of not going through comp-sci but have still been able to work for Google, publish books, lead teams and companies and products. You'll do just fine.

You have the ability to write some code! If you want to get a jumpstart, you should take the princeton algorithms course (for free!): https://www.coursera.org/learn/algorithms-part1

Or read the textbook by sedgewick that accompanies the course. https://algs4.cs.princeton.edu/home/

There is very little math in there - it may take some elbow grease and mentorship to help to convey some of the ideas - but I believe that you could implement and solve most everything in there. That was my path - I had a teacher at the age of 14 who would explain to me how different algorithms worked and I would go and implement them. Drawing a circle (in memory - it was in C!) or sorting a list (we did bubblesort first IIRC!)

I think you could do it! I believe in you! The course material is approachable - much more so than basically every other algorithms/data-structures material I've found. it may take you some time but you'll be soooo far ahead with your thinking about code.

If you ever start working with Object oriented languages like Java, another book that may help you when you've gone down the road a bit is the Head First Design Patterns book. http://shop.oreilly.com/product/9780596007126.do
It's very easy to read, mostly pictures. It is made to be very easy to read (all of the books in that series are so look around at them.)

It's helpful to do both - code and also take in some material, but at 12 I imagine some of the material may be a bit daunting. You're doing really well - keep it up.

These types of articles always give lists of books to read. I understand how important reading books are, but I've almost never been able to read a book about programming and get anything useful out of it; my brain just doesn't retain knowledge (only book that has come close is Head First Design patterns, but that book was trying to help me retain).

Most of what I've learned come from articles on HN, reading source code, classes in school, and my own experience in both personal and work projects.

How do I overcome this? Or do I even have to?

1. Head First Design Patterns - Didn't learn patterns in school. This book made a lot of difference in communication with more experienced programmers.

2. Pragmatic Programmer - A classic, learned many practical tips for day to day programming job.

3. Founders at Work - Motivated me to work on my side projects and be constantly learning.

I would provide you with book suggestions, but as I said, most of what I've learned is due to lectures and examples.

If you've got to have a book, I've heard that O'Reilly's Head First Design Patterns is pretty good for the patterns themselves (heard the same for most of the Head First series). That book uses Java.

As for when I come across a problem, I've found that if you search for your problem on Google you'll generally get a good result. You could also check out the Stack Exchange networks, specifically Stack Overflow, try under the Java tag over there.

While I've never really looked, you might be able to find a nice Open Course Ware class on learning Java, but again, I don't know if they exist or not.

The documentation for Java is also really nice and fairly easy to understand.

I recently had an on-site interview at a big SV tech company. I had 4 interviews and 3 of them flat out told me they haven't read my resume. I didn't do as well on the whiteboard hazing but I'm confident that I could have solved them if I had more than 30 minutes to come up with an efficient solution.

What disappointed me was, 3 of the interviewers had no idea about my background and weren't able to extract my strengths. Even though I am a new grad, I have interned for 2 years as an app dev and learned a great deal about design, code quality, testing and etc...

I have read Effective Java, Clean Code, and Head First Design Patterns. I'm reading Java 8 in Action now. I have not memorized them page-to-page and still need more experience to master them, but at least I know some of resources I can go to for more answers. I have participated in code reviews and enjoy them. I can implement LLRBT and many of the algorithms you can expect a new grad to know but I have not invested my time on hacker rank and uva.

I don't know what SV or big tech companies are looking for. I constantly hear interviewers say they want good engineers but fail to capture the essence of a potential good engineer well. What benefit is there in hazing anyone with problems many engineers don't deal with without the tools they use every day, and with an absurd time constraint. Kosaraju didn't come up with SCC in 30 minutes and he had a PHD. Sure I can spend hours studying for whiteboard questions but to what benefit. I am sure anyone of you can come up with a whiteboard problem you can't solve in 30 minutes, but what does that say about you.

Clean Code - Robert C. Martin: I got this book in college for a class and enjoy referring to it when I feel that my code quality is starting to decay.

Computer Principles of Modeling and Simulation - T.G. Lewis/B.J. Smith: I received this book as a gift from one of my favorite professors in college. It was published in 1979, but I find the material still relevant when it comes to introductory concepts of computer simulation.

Big Java Late Objects - Cay Horstmann: Another text from my time at college, specifically from my data structures course. I keep it because I like the way it explains fundamental data structures with well-written Java.

Head First Design Patterns - Eric Freeman/Elizabeth Robson: Another college textbook, and one of my least favorite reads of all time, but I'll be damned if it doesn't explain design patterns well enough for me to keep it around. I refer to it now and then but only when I feel like punishing myself.

Learning PHP, MySQL, JavaScript, & CSS - Robin Nixon: A dangerously outdated introductory web development text that I bought when I was in high school. It was the first programming book I ever purchased and I keep it around because I enjoy remembering what it felt like to explore web development for the first time. I've not referred to it in years, for obvious reasons, but it explained full-stack web development very well and gave me a foundation that I've been able to build on to this day. I remember standing in the tiny Computer Science section at Barnes & Noble where I found it, taking it home and cracking it open, and working through it until I had to make myself go to sleep. It's the first programming book that really hooked me.

I agree with the first reply that the book is overrated. While it's not irrelevant, I wouldn't think it fits into a "must read" list for people learning software engineering. I often hear, "Head First Design Patterns" as a better reference if you're interested in design patterns. I own the GoF book, but have thumbed through Head First and am inclined to agree.

What I think is missing is the idea that design patters are often language smell. They're common patterns to compensate for deficiencies in the language. The GoF is most applicable to C++ code that uses a lot of OOP. Like the previous reply said, reaching for these patterns too quickly complicates things. Like using unnecessarily large words when simpler language would suffice.

she cites psychological research -- except that it's the Gladwell/Surowiecki affirmative self-help for New Yorker readers kind of research.

She is certainly nowhere near as bad as Scoble: only Winer can keep him company in the innermost circle of blog hell.

I had totally erased that damn Head First Design Patterns book from my memory, maybe she does belong in an inner circle of hell...

I've heard design patterns described as "missing language features" and when you look at the GoF book, many don't make sense in languages other than C++ because they're already built-in or unnecessary.

If you're looking for a newer book on design patterns, I've heard Head First Design Patterns (2004) suggested as much more approachable. The cover image is a bit goofy and screams mid-2000s. I've only seen excerpts, but GoF if I remember correctly is very dry and doesn't explain some things very well. Head First Design Patterns looks to be written for Java, but I don't remember having trouble understanding and implementing them in other languages.

Head First Design Patterns: Building Extensible and Maintainable Object-Oriented Software 2nd Edition will be released on December 29. I guess this is the newer edition? It shares 2 of the authors.

> Perhaps the problem doesn't fit into an object oriented solution.

Or if not the problem, then my brain.

> You could try learning a functional language and see if you find it fitting better.

I come from a physics/science background; what I've seen of functional languages feel natural.

I bought my first book on design patterns 12 years ago (Head First Design Patterns). I worked my way through and it didn't make sense. I've dipped into PoEAA and Gang of Four since, with the same problem. The flow-chart-esque (UML) diagrams, the way messy life is meant to fit patterns... it didn't gel.

Time to try again, but I fancy learning a functional language first :)

I haven't bought them either, but I do think there's a market.

There are some people who are in technical departments that are not necessarily software developers but due to their responsibilities have a need to understand some technical concepts. I know we have at least one in our department. For him to spend $12 on something that will help him understand what we do better would certainly be money well spent.

They kind of remind me of the Heads First Design Patterns book.

Pragmatic Programmer (importance of plain text) and How to Solve it (set of logical steps to get to grips with an otherwise overwhelming problem / situation).

Applying Domain-Driven Design and Patterns was the book that made me fall in love with software engineering. Perhaps a little dated now though.

Head First Design Patterns - I never grokked any of the patterns from the GoF book, but this one 'clicked' for me, if you can get past the cutesy presentation.

Peopleware - Shows importance of focusing on people, rather than the tech, as this is often the main cause of project failure in the software realm (and perhaps others).

Here are some of resources you can use for learning CS topics related to interviewing. You don't have to do all of them, do as per whatever combination suits you.

For learning Algorithms and data structures for interviews

1. Coursera courses on Algorithms by Prof Roughgarden

2. Coursera courses on Algorithms by Prof Sedgewick

3. OCW 6.006 as listed above would be good too.

4. Prof Skiena's algorithms course

5. Berkeley CS 61b by Prof Shewchuk for refreshing basic Data structures like Linked list, tree traversals which are not covered in above mentioned courses.

For practice,

1. geeksforgeeks.org

2. leetcode.com

3. interviewbit.com

4. careercup.com

5. Hiredintech.com

6. topcoder, hackerrank , spoj etc are good sites for practice in general but their problems are embedded with extraneous information not seen in interviews. For example, interviewer is not going to explain you 2 page story, instead he will tell you directly what needs to be done.

In books,

1. Cracking the Coding Interview

2. Programming Interviews Exposed

3. Elements of Programming Interviews

Books on Design Patterns

1. GoF

2. Head first design patterns

3. Software Architecture books by Robert Martin

4. Elements of Enterprise Architecture Patterns by Fowler

5. System Design research papers, gainlo.co has many design questions

I find this statistics to be interesting because technically, outside Android, there's probably not too many new books about Java published by O'reilly unlike in the early 2000 when Java for the web and enterprise exploded.

On the flip side, Head First Design Patterns, Head First OOP, Head First Software Development are all using Java and the Head First series seems to replace the "For Dummies" series for beginner's book (don't get me wrong, I love Head First series because the series attempts to write book from a different angle and it does make sure you remember what you read, just like in the classroom).

Last but not least, O'reilly has the best selection of JavaScript books out there compare to other publisher.

[edited typo :)]

Technical concepts for writing code:

--------------------------------------

Clean Code (Robert Cecil Martin)

The Art of Unit Testing (Roy Osherove)

Head First Design Patterns (Elisabeth Freeman, Kathy Sierra)

Martin Fowler's blog: https://martinfowler.com/

.

How to gather requirements and write business-readable code:

--------------------------------------

Domain-driven design (Eric J. Evans)

Implementing Domain-Driven Design (Vaughn Vernon)

Patterns, Principles, and Practices of Domain-Driven Design (Scott Millett)

.

Remaining agile and managing your work according to your clients' needs:

--------------------------------------

The art of doing twice the work in half the time (Jeff Sutherland)

The Mythical Man Month (Fred Brooks)

If it's Head First Design Patterns, then yes. :P

In all seriousness, I highly recommend the Head First series of books. They read so much smoother than other large reference/learning books.

As for Design Patterns, the value in that was not that I learned any specific patterns, but rather that it got me to analyze software design in a systematic way rather than a "I like this" way.

I believe they are grasping in the right direction, but what they really need to do is let go of the attachment to object oriented development. I don't mean to start the flame war, but if you insist that the architecture reflects the intent of the application, then why choose OO? If the architecture requires messages and buses and adapters, etc. what does OO bring to the table? Why do I think I need distributed objects? Am I choosing micro-services just because I want to try to get distributed objects working again?

It's not a language issue either. At this level we are talking about frameworks, models, domains, contracts, protocols, etc. This layer is not language dependent, although some languages are better designed to build frameworks that support these intents.

A classic example of how these assumptions creep into your designs is seen in the first chapter of Head First Design Patterns where they discuss at length how to create the perfect object model for a duck computer game. When I read that the first first think that came to my mind was, "Wait a minute, you are designing a computer game! Everything on the screen is a sprite. Sprites are moved around the screen by their coordinates once per game loop. How does the perfect duck object model help me here?"

Sounds very much like a hammer looking for a nail to me.

[edit] fixed a few typos

It seems like you have a grasp of what is wrong already. Stuff you can do right now without reading a book
- Use source control
- Enact a policy where all new code is to be well tested (which you can enforce with some build/checkin system)
- Make a refactoring change to isolate sections of code that minimally touch other sections and separate them into projects

As for books, I would suggest looking at Head First Design Patterns by Freeman and Robson. This isn't explicitly about project design, but it is about designing reusable code modules which can really help in any language. It is aimed toward object-oriented languages, (the examples are in Java) but it has helped organize my code in other languages as well. If you're using the OO facilities of Matlab, VB and python this can be useful.

> check out the GoF book

Oh dear God, that's the last thing he should do. That book is so incredibly dull. It makes Death Valley look like a lush rain forest.

Might I suggest Head First Design Patterns [1] as a good introductory alternative that won't sap his will to live.

[1]: http://www.amazon.com/First-Design-Patterns-Elisabeth-Freema...

I modded you up even though I disagree with you.

Using design patterns really helped me in a large project I did in C# two years ago - although I must admit I used the friendlier Head First Design Patterns as my reference rather than the original Design Patterns book.

I honestly think I would not have been able to do the project without the aid of design patterns. The project's architect was living too high in the clouds to grasp why his architectures were unimplementable, yet tried to micromanage the implementation as well. He continually specified implementation details which violated basic constraints of the language syntax and the static type system (like asking for multiple inheritance in C#). So I would use design patterns to get around a language limitation to do something close to what he wanted. Since he didn't understand design patterns, he found my explanation of how the design pattern accomplished the trick impenetrable enough to just leave it alone.

It backfired on me when he learned the Singleton pattern (which he kept mistakenly referring to as the "Simpleton" pattern), and started insisting that every object should be a "Simpleton".

Anyhow so the reason I didn't downmod you, is that I do think design patterns are useful, but they fix a problem which is partly that the language is broken, and partly a people problem.

I was in the same situation as you a couple years ago. I'd taken programming classes in high school but I was unsure how "real" software was written.

So, I started learning about design patterns. In particular, I spent a lot of time reading through this site [1] and "Head First Design Patterns".

It was a mistake.

I've used maybe 2-3 of these design patterns when actually writing code, and never because I intended to use, say, a factory or a singleton -- I wrote what code I thought was most appropriate and it turned out to match an existing pattern.

--

Here's what's more valuable to learn:

- SOLID principles

- Realizing that what depends on what in your web application matters.

You want your business logic depending on your DB access code and your web layer depending on your business logic.

You do NOT want your business logic depending on your web layer.

- Realizing that your web app is really just some business logic which has a HTTP interface.

- Organizing software into layers. In a web app you'd have layers for middleware, controllers, business logic, and database access.

- Folder structure. I have a folder for each layer and try to have a descriptive name for each file in it. If a folder is getting messy, add another folder inside it with a descriptive name.

- Understand that refactoring is a fact of life. When you start a project, there's no way you can think of the optimal design up-front. This means you'll write code, accrue technical debt, and will need to refactor. Realize that this is 100% normal.

[1] https://sourcemaking.com/design_patterns

Couple of things:

1) You'll likely get better/more response if you prefix your post with "Ask HN: " (lots of folks have triggers for that type of thing)

2) You don't have to be a mathematician to be a good programmer. Tons of great programmers were not comp-sci majors so don't let that sort of thing get you down. If you've done "some basic noodling here and there... in a few languages" and you want to improve as a programmer, I'd advise you to:

   - Pick a language
   - Pick a pet project
   - Buy a few books or take a few online classes that are on your chosen language
   - Begin reading the book
   - Implement your project while reading the book
   - Find some sample apps written in your language and review how they did things differently
   - Finish your book and buy another book/class that is specific to your language
   - Pick a new pet project and implement it
   - Review some open source apps written in your language
   - Contribute to some open source apps

At this point you're likely ready to spend a bunch of time reading non-domain specific books but, up until this point, the value you would receive from reading books not directly related to a specific language/task is debatable. Now that you've had some experience, I think this is a great time for books like:

   * The Pragmatic Programmer
   * Code Complete
   * Head First Design Patterns
   * The Mythical Man-Month
   * Design Patterns: Elements of Reusable Object-Oriented Software

(Those are all titles of books BTW)

Next up: build a startup!

Notice there are no math books in my list. This is different from what others would propose but, given the scant description you wrote, I don't see any need for math except to satisfy a possible desire to learn.

That's a terrible book (and series) to learn from, the level of visual clutter on each page distracts from the actual task of learning anything. I had a copy of "Head First Design Patterns" and after only a few pages I thought my eyes were going to fall out.

I found Bruce Eckel's "Thinking In Java" useful back in day to learn OO programming and concepts. Much of what you learn is transferable to other languages.

The problem with GoF (haven't read it cover-to-cover, but have browsed it for inspiration) is that it is more or less an encyclopedia. It lists the discrete patterns, gives them names, as if they've come down the mountain on stone tablets.

I found a book like Head First Design Patterns to be much more bottom-up. It hammers home the idea that discrete design patterns really are just the organic side-effects of applying concepts (meta-patterns?) like "composition over inheritance", "don't repeat yourself", etc., to recurring problems in computer science.

Learn about Design Patterns, they will force you to really use Java's features such as Interfaces and Abstract Classes, accessibility modifiers (public, private, protected) and others. That is the method I use when tutoring individuals in similar situations as yours that want to get back into Java specifically.

I recommend the Head First Design Patterns book if you're not turned off by the less-than serious nature of it. I really did not like the book at first glance, but after actually working through some of it as instructed I enjoyed it and really developed a solid understanding. Simple examples like Vending Machines and Washers really helped me, I still use them in my head when thinking about problems.
Design Patterns are not always the best solution and forcing them on problems can make things worse, but as far as teaching Java I really recommend it.
http://www.amazon.com/First-Design-Patterns-Elisabeth-Freema...

I also recommend learning about Test Driven Development as previously suggested, we use JUnit4 to teach our undergrads at my university. There are also other methods of testing besides TDD, but I feel it was the easiest to help students.

This is an old post, and I've never quite agreed with it.

For one thing, I don't know how you can lump things like Head First Design Patterns or whatever the TDD one is in with things like Code Complete or Programming Pearls.

For another thing, I have read at least parts of all of the books that apparently programmers don't really read, and judging from the books on colleagues' desks (not the bookshelves) so have a lot of other people I've worked with. The same is certainly not true of the "books programmers do read" list.

There are books that nobody reads because they don't contain good ideas, and there are books that nobody reads because they're too dense. The second category contains some of the most valuable books out there.

I'd put the gang of four design patterns book into the second category. Often, a book or journal article is there to be cited as a breakthrough work on a subject, but very few people read it - instead, they read the thousands of other, more easily accessible books and articles on the subject.

This is why "Head First Design Patterns" is in the "books I've read list", and "GOF" is in the books nobody reads list. GOF is on my shelf, and I've browsed through it, but I go to other sources to understand and implement design patterns.

I've seen multiple people mention the GoF's Design Patterns book. This is well known and worth several reads through; it will take multiple passes to grok all of it.

There are several other books that have tried to explain the GoF's Design Patterns in either an easier to approach manner, or in the context of a specific language they have tried to explain where new design patterns have emerged or the original patterns had mutated.

A couple of those worth checking out are

"Head First Design Patterns"

http://www.amazon.com/Head-First-Design-Patterns-Freeman/dp/...

"Design Patterns In Ruby"

http://www.amazon.com/Design-Patterns-Ruby-Russ-Olsen/dp/032...

"Learning JavaScript Design Patterns"

http://www.amazon.com/Learning-JavaScript-Design-Patterns-Os...