I have a repeat coming up in Computability and Complexity and I was wondering if anybody has good resources for this sort of study.
Things like regular languages, context free and context sensitive languages and all that sort of stuff.
For example:
As you can see, it is a horribly phrased question. The notes our lecturer gave us are equally as bad. I really need to pass this module so if anybody has a good resource for studying these topics it would be much appreciated.
I think the problem you're having is not the fault of the phrasing, but the fact that you're not yet comfortable dealing with the mathematical notation involved.
Wikipedia has a lot of articles on automata and other computer science theory topics. Also, a google search on 'NFA to DFA' turns up many helpful results. Automata are used heavily in compilers, so you might find a more "practical" explanation of things in material from a compilers course.
Your class is going to be heavily mathematical, though, so you would do best for yourself by putting aside the attitude that the material you've been given is poor and spend the time learning to understand it. Mathematical formulations give you precise and concise descriptions without as much room for misinterpretation as informal language has.
You may want to look at the class notes made available by Avi Kak at
https://engineering.purdue.edu/kak/courses-i-teach/ECE664/Index.html
See the handwritten notes on Lecture 17 that explain the notation in your question.
I have been working on SAP technology for the last 2.5 years.
As there were so many technical concepts, I couldn't get a single source where I can learn about everything related to it. I didn't get the confidence of mastering all the technical concepts.
Please help me out if you have faced such an experience and how you overcame it.
Suggest some books or a methodology you followed which may be helpful.
Note: I have already worked in Java/J2EE. I am confident enough in mastering the concepts.
Obviously the (or rather a) correct approach would be one that works for you, the conclusion being that you don't know whether the approach was correct until you've tried it. :-)
Enough philosophy - my suggestions would be:
Learn how to read the SAP Online documentation. That's a bit different from reading other documentation - the SAP docs are littered with information about legacy techniques that you don't really need. Learn to identify and skip these parts - you can always come back later.
Develop a knowledge of the data dictionary. It's really at the heart of all things, and if you can't navigate there and read the structures, you're lost. Start reading the chapter in the online docs at http://help.sap.com/saphelp_webas620/helpdata/en/cf/21ea0b446011d189700000e8322d00/frameset.htm.
Read http://help.sap.com/saphelp_webas620/helpdata/EN/fc/eb3138358411d1829f0000e829fbfe/frameset.htm. I know that's a lot of stuff, but it's available for free, and almost everything is in there. Again, do a "fast indexing run" first to get a feeling of what's inside there, then dig into the basic concepts. ABAP at its lowest level isn't fundamentally different from other imperative / procedural languages.
Follow the example programs (transaction code ABAPDOCU). Learn how to use the debugger (vital!) and understand what's going on in the demo programs.
Once you've got a mental model of the basic language, take a look at ABAP Objects. If you already know Java, there should be no problem with the basic concepts, but there are a few specialties.
Feel free to ask if you run into something you don't understand.
There is no single source of information that will provide you with everything you have to know, especially since some of the knowledge is very specific to the context (FI, MM, IS-H, ...).
I am taking a Digital Circuits class in which we do not use a book, only lecture notes. In the section that covers adders I only have 2 small examples covering addition and subtraction of binary numbers. I am pretty sure i am going to have worded problems in the exam such as design a circuit to count something etc. Does anyone know any sites that have example questions and solution for me to go over?
I don't know of any particular sites, but I do know that when I took a similar class, the lecturer was awful and I relied entirely on the textbook. It was Digital Design, by M Morris Mano. I highly recommend it - it's got plenty of problems to go over and has all the information you need in case you get stuck on something.
Wikipedia is a useful resource. The best way to learn electronics is to build your own circuits, preferably with real hardware or using a simulator if the former is not practicable.
P.S. You do not need adders to count events. A cascade of bi-stable flip-flops will do this.
I've been searching the web for some time now. I am looking for small sample exercises for OOD practice (& for some internal TDD workshops).
If there is one single place, where this need is being served, please point me to it.. and close this question
Constraints:
Language-agnostic real world problem
Small : Something that takes an hour to two at max to solve (or has sub-parts that can fit this constraint).
Not Algorithm centred : Not be focussed on just solving a computational task. (There are multiple sites that serve this category.) Involve > 2 interacting entities.
Solved by multiple people, preferably yourself : Goodness verified. Links preferred. Please do not post something that may be a good exercise... subjective
Similar SO question 60109, but the answers dont meet my need here. I found that I've lost my touch (was thrashing ideas) with OOD after prolonged exposure to a day-job. Need to get it back..
Update: Are we collectively out of short OOP exercises ? I was hoping that I'd have a bunch to pick from. However my web-searches (this is a diff exercise in formulating the right search string) and the lack of responses here seem to indicate otherwise. Maybe I posted to SO at a bad time.. in which case bumping this thread for more responses.
http://butunclebob.com/ArticleS.UncleBob.TheBowlingGameKata
http://schuchert.wikispaces.com/Monopoly%28r%29
Jeff Bay's Object Calisthenics. Following these will improve your OO skills.
Bill Wake's spreadsheet TDD challenge
Dave Thomas' CodeKata
Kindness,
Dan
From the AGPPnP book by Robert Martin aka UncleBob
CoffeeMaker Mark IV - Page 2 has the problem statement
Questionnaire Practice Problem
A problem I've worked on in a couple of different jobs is that of writing some generic, data-driven survey/questionnaire functionality. It's not majorly complex, but has enough interesting avenues to be a good OOD practice problem I think. It's definitely real-world and crops up in a lot of places.
You can start off thinking about how to structure a Survey. It is obviously made up of Questions, but do you also want Categories? Can a Question have subquestions? Can a subquestion have subquestions? How deep can you go?
A question probably needs to have potential Scores. What types of scores can you have? What types of questions can you have (multiple choice, multiple answer, freetext, etc.)?
Once you've got the basic business logic, you can also think about how you display a survey . Maybe you have a SurveyRenderer and a QuestionRenderer? How do you decide how to render different types of questions? (Maybe you use a Strategy pattern... as in this SO question.) How do you render a read-only version of the survey?
You can also think about persistence. How do you record responses to a blank questionnaire? How does your object graph of a survey get mapped into a database (or some other backing store), and vice versa?
As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 11 years ago.
I'm a confused newbie and hobbyist programmer trying to get a grip on this, so forgive me if my question is a little off or doesn't make much sense.
I see a lot of questions on SO revolving around the use of design patterns, and I'm wondering if anyone has a good resources for learning about, and implementing design patterns? I understand the general idea, and know how/when to use a couple of them(Singletons, Factory methods) but I know I'm missing out.
(Just in case it matters, my language of preference is C# but I could learn from examples in other languages)
Head First Design Patterns
and the Design Pattern Wikipedia page are the best resources for beginners. FluffyCat is another good, free online resource for design patterns in both Java and PHP.
The Gang of Four book is where to go afterward, but it's fairly advanced, so I'd wait until you have a pretty firm grasp from the other resources.
Design patterns are great for various reasons:
gives you a starting for solving common problems.
gives developers a vocabulary to talk about certain ways of solving problems in a very compact manner.
when working with developers who know design patterns and you use design patterns in your solutions they will understand the solutions a lot faster.
But when your goal is just to learn design patterns I think you are missing the fundamentals. All design patterns are based on more common principles. High Cohesion, Low Coupling Open Closed Principle, DRY, Liskov Substitution Principle etc. For these fundamentals I would read the following books in this order:
Head First Object-Oriented Analysis and Design (Head First) [ILLUSTRATED] (Paperback)
Applying UML and Patterns (Hardcover)
Agile Principles, Patterns, and Practices in C# (Robert C. Martin Series) (Hardcover)
After that you are ready for the basic gang of four design patterns
Head First Design Patterns (Head First) [ILLUSTRATED] (Paperback)
The BIBLE
A nice website (don't buy anything, it is not worth it) http://dofactory.com/Patterns/Patterns.aspx (some implementations of this site are worth a discussion
The next step:
Patterns of Enterprise Application Architecture (Addison-Wesley Signature Series) (Hardcover)
The POSA books
And always remember : the pattern is not the goal !
I'd add that Design Patterns book from the "Gang of four" is a bible for anyone who is seriously interested in design patterns.
My tip:
Read a lot about the patterns from different sources.
Trying to force as many patterns as possible into all the code you're writing as this point is not going to give good results. Instead, let the information rest inside your brain for a while (read: months).
Suddenly you'll find yourself stumbling upon a problem or piece of code and you'll vaguely remember that you've seen something that might work as a solution to this particular problem. Now is the time to look up the details on the pattern you are thinking of and try to apply it.
That's what has worked for me, anyway.
Design Patterns
This tutorial site contains following sub-sections
Intent of each design pattern
Real World Structure for the design pattern
A Problem statement
Detailed discussion on the problem
Checklist on how to arrive at a pattern
Rules of thumb while arriving at pattern.
Code snippets for the design pattern which includes C#, C++, Delphi, Java and PHP
This site also contains guide on Anti Patterns, UML and Refactoring.
Bruce Eckel has a book on design patterns, although it's Java, it's like all of his books amazing. And the best thing is, they are free!
C# 3.0 Design Patterns for a C# perspective on design patterns.
(source: oreilly.com)
An introductory book that I found useful and well written is
Design Patterns Explained by Alan Shalloway and James Trott (Addison Wesley).
Do not start from the Gang of Four book, for it is not an introductory book by any means.
I would recommend taking a look at Jean Paul Boodhoo's quintology (?) on Demystifying Design Patterns on DNRtv, urls supplied below. The videocasts touches on Singleton, Abstract Factory among others- the difference being that you can watch him code as he discusses the theory. Good to watch over lunch on a rainy weekday.
http://www.dnrtv.com/default.aspx?showNum=63
http://www.dnrtv.com/default.aspx?showNum=65
http://www.dnrtv.com/default.aspx?showNum=68
http://www.dnrtv.com/default.aspx?showNum=71
http://www.dnrtv.com/default.aspx?showNum=92
An annotation to the above comments.
A Quick Reference For GOF Patterns
Here is a good place you can start dofactory.com/patterns/patterns.aspx - You can find link to each pattern, along with corresponding implementations.
How ever, remember that these are GOF patterns. You might need to read and understand advanced patterns as well, once you gain enough expertise in OOAD. Head First Design Patterns is a good start, and after making some progress, go with Martin Fowler's Enterprise Application Architecture Patterns.
Applying Design Patterns - The Thought Process
Another main aspect - Applying Design patterns is as important as just knowing them. Reading these articles might help you as well.
Applying Design Patterns Part I
Applying Design Patterns Part II
Hope this helps
Head First Design Patterns is a good one like others already noted. Besides this, of course the original book and C# Design Patterns. Also there are good websites already mentioned.
Besides self-learning, I seriously recommend starting or attending a pattern study group in your area. See A Learning Guide To Design Patterns for explanation and great order to study the patterns in. We did this and I can honestly say that I would not understand as much as I do now. A weekly meeting with other interested people keeps you surprisingly disciplined when learning something abstract like design patterns.
Happy studies!
Before spending money on books I would recommend Wikipedia's excellent design patterns page. Also for something different Google for "design pattern screencasts" or search for "design patterns" on YouTube. Getting the same information presented differently often helps the penny drop.
The Gang of Four book is the definitive text on the most well known patterns but is not that easy to read and with C++ examples not everyone's favourite.
The Head First Design Patterns text is far more accessible but only contains a subset of the Gang of Four patterns.
The most important thing is to understand where and why a particular pattern is useful. Afterwards search the web for implementation examples in the language of your choice and experiment until you "get it". Understand one pattern before moving on to the next. Everyone understands some patterns better than others (and there are hundreds of lesser known ones).
Just keep plugging away.
(source: Amazon)
Patterns of Enterprise Application Architecture (Hardcover) by Martin Fowler
Refactoring to Patterns (Hardcover) by Joshua Kerievsky
Continuous Integration: Improving Software Quality and Reducing Risk (Paperback) by Paul Duval et.al.
Beyond Software Architecture: Creating and Sustaining Winning Solutions (Paperback) by Luke Hohmann
Design patterns are like any library function, read about them, then when a problem comes up, the design pattern will be in your "Toolchest". There are many design patterns books all patterned after the original "Gang of four" design patters.
For any programmers, I think that and the Refactoring book by Fowler are the absolute minimal requirements.
For websites, a very good site is http://ajaxpatterns.org, from one of the developers of the ajaxian website
The original Design Patterns book is a must-read for all programmers.
It is an excellent book on every level: layout, clarity, insight, depth. It's one of those great books that you first read cover-to-cover, and then use as a reference until you literally know it inside out.
You could start by the Wikipedia page, but treat yourself with the great book too.
Applying UML and Patterns by Craig Larman. Start from the basic of analysis, design and uses a simple Case scenario. Introduces most of the basic patterns in a simple way.
If you read about design patterns you'll notice that Java seems to have a few of them implemented.
Look at the source for any framework and you can glean info about design patterns. Personally I don't see them fitting in perfectly to any of my code, sometimes the examples in books and tutorials seem a little idealized, especially for the lone coder.
Design patterns aren't for lazy coders.
For me and my colleagues study Design Pattern that following on Pattern Study Group. They prepare a list of each pattern that we should learn in order and also have the opening questions that make more discussion in group.
I also suggest having a shufty at Refactoring to Patterns once you've read Head First Design Patterns.
Note: The code examples are in Java, but should be very similar to C# examples...
It does not make too much sense to me for someone with very little experience to delve too far deeply into design patterns. It is great to know they exist, but at this point you should focus more on other things rather than just learning about design patterns.
They are useful in context of a problem - as a concept for a new/beginner developer they are really not too much practical value aside form knowing that you should make use of them when and where you can.
EDIT
To clarify - many design patterns are a result of problems found in some domains. A new programmer can hardly be expected (IMO) to know the design pattern(s) to use for some set of problems. Just as we get a smattering of algorithms in CS studies, we need an understanding of the things we can do with patterns and their benefits, but when a person is still building hello world or discovering stl there is not much practical need for design patterns. Patterns are great. But they are not the silver bullet.
(Neither was CASE (tools), neither is/was UML, neither is SCRUM, neither is TDD, nor STL, nor Java, nor XML, etc. ) These are all just aspects of our profession and to treat these topics as the second coming is naive.
Patterns comprise the high level vocabulary programmers use to talk about abstract design. If you are reusing an abstract solution, it is helpful to refer to it by name. If you invent a pattern, it is professional to do a little checking to make sure it hasn't already been given a name. If it has been named, then the description may be useful.
After you code even a tiny bit, you will notice yourself writing something similar to what you coded before. This is a pattern. Even if it is a tiny pattern, it is worth noticing. Is there a better pattern? Do you see certain tiny patterns cooperating together to solve a larger problem? Well next time, when you want to solve larger problem, the entire pattern comes into your mind as a single chunk. Fleshing out the detailed lines of code becomes mechanical.
The more you notice patterns, the easier programming becomes, and the more you will appreciate some of the biggest and best patterns worked out by other programmers.
Try mastering the MVC pattern. One way or another, variations show up all over the place, even in tiny design decisions.
Once you understand the concept, go through the Eclipse source code or design, lots of really good examples of these patterns (no surprise, Gamma was one of the designers).
I have found Design Pattern articles on this website really easy to understand
Design Patterns in C#