Previously on CS410J...
This was the first time that I had graduate students in the course in addition to undergraduates. Let's hear what they had to say...
- What do you wish you had known before taking this course?
- Some background surrounding the APIs.
- Server and client relationship and asynchronous call handling
- I already had programmed with Java quite a bit before this class so there was really nothing that was too surprising, and I really don't think there is anything I wish I had known before taking the course.
- I didn't feel I was un-prepared for the subjects that were covered, despite being exposed to a number of new tools.
- The only thing I can think of that would have helped out would be to have some familiarity with the tools like Maven and IntelliJ IDEA. Other that that the assignments had a good difficulty curve and a nice progression.
- I would have liked to have known more about REST and GWT. While I think that both the web assignments went very smooth overall it just kind of left me feeling like I could have done so much more if I had a deeper pool of knowledge on the subject. However, that is the point of taking the course so it's really not that bad.
- That this class would require as much work and time spent watching videos as it did. I might have chosen a different course that was less interesting.
- I wish I knew a little more about the Java language to be able to perform better in HW assignments.
- How classpaths work, basic knowledge about IntelliJ & adding external libraries, etc. to an IDE - mostly environmental stuff.
- I wish I would have known more about program design, as well as more about Java idioms. Which is what I was hoping to pick up more in the class. I feel I waited long enough and put in enough work outside of class to be able to help myself quite a bit when needed, so overall I felt pretty prepared.
- Nothing really... I find this class easy, fun, and a great summer course.
- i wish i had known basic java. i knew oops, but knew very little of any java
- I wish I had known a bit more about integration testing, because that's an area where I tended to skimp on the projects. Not necessarily because you didn't cover it well enough, just because I was unfamiliar enough with it to tend to go lighter in that area.
- Not a lot - I felt adequately perpared for the class.
- How to use maven properly. It caused me a lot of grief at the start of the course.
- I have a decent knowllege of java so, i didnt have much issues.
- A bit more about the Java API. It's not too hard to pick up throughout the term, but there are a lot of ways to do the same thing and naturally, some are better than others. So, if I knew which parts of the API are best for what, I probably could have made better design decisions throughout the projects.
- I wish I had known more about REST and HTTP because I had a hard time working on project 4 and 5, but I'm glad that I managed to work it out and learn about it.
- I would have liked to know more about Git, as that was glossed over; I have a Git, but can imagine students not having one, and just forgoing any version control--I definitely heard this happening this term.
- Anything at all about web development or the use of client/server communications. I'm still not clear on how any of it works. There was a lot of handwaving and basing my code off of what I saw already in place.
- I wish I have known about TDD so I could be faster and more productive.
- More practice using .git.
- Honestly nothing. Kinda set up for a intensive "senior" class.
- I wish I knew more about design patterns.
- I didn't have experience with JUnit and Java TDD, but that's why the course was great!
- I wish I knew more about maven, but that isn't really required for the course.
- More about object oriented programming styles, as well as inheritance.
- Distributed systems and the details of how HTTP works.
- That there would be a lot of code-writing to sit and watch during lecture. Not that this is necessarily a bad thing. Just different than what I was expecting.
- How long each project is going to take! They are simple, but lengthy
- I wish I had more programming experience in general. Previous undergraduate programming courses did not prepare me well to program using APIs and libraries. However I'm probably coming in with fewer CS courses than the typical student.
- That studying the online materials was a necessity, not really optional.
- Not really much. It might be nice to tell people that it's super important to have a *NIX based system for this course, though.
- I wish that I had more knowledge about REST, distributed computing, algorithims, design patterns, and the new capabilites of Java 8. Aside from content, I wish that I had known that the official course period would include little lecture time, and, consequently, we would be expected to watch lecture videos outside of class. I found that there was a substantial jump in the difficulty of the assignments from program 3 to program 4 (along with everyone else it seems!). Having come into the course with fewer than three months experience in java programming there was a substantial amount of growth that I undertook this summer, some of it painful due to my lack of knowledge in the areas described above. If I had experienced (minimal) prior exposure to REST or distributed computing I would have been able to learn more beyond the basics. Regarding algorithims, design patterns, and Java 8, I felt that while I was able to create programs that worked and met the specifications they did not do so in the most elegant and efficient ways. Doubtless, with more time I would be able to refine and improve them; however, if I knew more about these topics before taking the class I feel that the amount of effort and hours spent thinking of ways to make things work could have been reduced, along with the efficiency of my programs.
- The course was fairly advertised. I had to learn some OOP concepts and Java idiosyncracies on the fly, but overall, I didn't feel that there was anything I was not able to tackle.
- More experience and understanding when it comes to understanding the client server aspects of web calls.
- I wish I would have known about the RESTful services and GWT even more better before taking this courese.
- -Basics of Java I/O (FileWriter, System.out, System.err) -Commonly used classes unique to Java (StringBuilder, PrintWriter) -That IntelliJ can be slow, buggy, and unreliable
- Java core API and network protocol
- I dont think there is something like that.
- A little bit knowledge of GWT would be of great help, Although I learnt a lot about GWT in this course.
- Working with some of the tools such as Maven and GWT.
- A little knowledege about GWT, Servlets
- When I read the course title for this I took it as Advanced Java Programming when it really was Advanced Programming in Java. I was hoping the lecture would go into a lot of the advanced new language features and maybe inner workings of the JVM. The material of the course is good but I have already heard most of it in my undergrad. I also wish I knew that this course was previously an undergrad only course.
- I wish I would have had thance to complete a basic Java class first instead of taking an Intro class concurrently. That was purely my choice, however, and has nothing to do with the superior quality of this class.
- What is the most important thing you have learned in this course?
- Learning the basics around the APIs we used as well as how to better utilize the documentation surrounding them.
- Saving work in repository could be very useful and the depth of java unit / IT testings
- GWT is relatively easy to use, but sadly very, very out of date.
- Web-dev. Prior to taking this class, I had yet to be exposed to any web-dev in previous classes (despite how prevalent it is) and I greatly appreciate the introduction I've had through this course.
- For me the most important thing would be learning about Maven, REST and Web App development using GWT.
- Test driven development. While it does take a considerable amount longer to program in this way it's so worth it. It allows you to have confidence that your code does what it's supposed to do every step of the way. Relating to this, another valuable lesson I learned is that just because all of your tests pass doesn't mean that your code does exactly what you think. Tests are a very narrow view of the overall behavior that a program can possess and I think that's valuable to remember as well.
- It is important to use resources to solve a problem and how TDD works. Learning Java on the side, I learned how to use libraries and how to use IntelliJ.
- The basics of creating a Java application in an IDE using libraries/APIs.
- I would say the most important thing I have learned was the TDD portion. Although I didn't use it as much as I was hoping to (mostly due to time constraints and already trying to figure other things out)...it was presented pretty well, and will be something I explore and get more hands on experience with as I move forward.
- Client/Server API and GWT
- i learnt a whole lot of java. I feel i can write code in java with fair amount of confidence now. I became aware of a whole lot of utilities in addition to advanced features like GWT.
- I think the most important thing is really the value of test-driven development. Having the projects set up with Maven to facilitate the ease of testing really made it a more enjoyable experience, and allowed us to focus on the tests rather than the setup. The value of Maven is also really apparent after taking this course, even though we did not cover it in great detail.
- It was even more ingrained in me the importance of unit tests and TDD
- Definately getting introduced to gwt. This term I had spent a lot of time programming in php and javascript for my capstone, and I had a terrible time. gwt is much easier to use, since I can avoid the javascript and opt for my favorite language instead.
- API stuff, you dont get much of that lkind of web dev stuff in other courses.
- The power behind test driven development. It is hard to stay true to this methodology, especially as the code that you're testing becomes more complex, but I can definitely see how it allows you to know exactly what your code is capable of as you develop.
- The most important thing that I have learned in this course, first of all, is time management. I'm taking this class along with my internship at Intel, so it was sometimes very busy for me to manage works for both places, but I'm glad that I did it. The second thing that I've learned is how client and servers interact with each other, JUnit test, how maven works, and other Java syntax. They're all useful and interesting.
- Maven and GWT! Awesome resources that I will continue to explore and play with. I'd be lying if I said TDD wasn't up there as well.
- Details of java, courtesy of the koans
- That using and mastering an IDE with TDD makes you a good developer
- How to use Java more effectively. To be honest, the koans were some of the best "learn a language" things I've ever done.
- TDD, unit testing and intergration testing. Also, laying down a solid foundation of project workflow in a Java environment.
- Java is an intensive language and can be use anywhere. I also really liked how it gets used in the real world.
- The existence of Maven.
- This was the first CS course I've taken to even mention architectural patterns like dependency injection and the usage of powerful APIs like class reflection. I found those topics to be, by far, the most valuable.
- Writing unit tests and integration tests.
- Test Driven Development/Unit testing strategies by far
- There is so much beyond just the language itself. The frameworks for testing (JUnit/Hamcrest), mocking (Mockito), dependencies (Maven), Web serving (Jetty), Cross-compiling (GWT). We learned a lot beyond just Java this term.
- The Java Streams API along with lambdas. It was cool practicing using both together in my projects. I also enjoyed learning/employing anonymous classes in project 5. Finally, learning concepts of TDD and having an encouraging environment in which to practice it was important.
- Do not procrastinate
- Not sure what the most important thing is. I feel that I've learned a lot - I'm barely wrapping my head around the all the things I've learned each week before we move on. This is not a bad thing though. The more impactful things I've been exposed to are unit and integration testing.
- How to work in an Object Oriented design pattern.
- Creating web apps, TDD
- There is a tie between the two most important things I have learned in this course: the sheer flexibility/breadth of Java and distributed/web computing. Before taking this course I had seen the tip of the Java iceberg visible above the water, all the while knowing so much more lurked below the surface. With this course I've seen below the water and am thrilled to see just how much there is - even though I know there's still so much more we haven't explored! Simultaneously, this course was my first foray into distributed computing and building a web application. Given how much occurs on the web, and I believe even more will be done on the web in the future, I am grateful to have had the opportunity to learn the basics of creating Java programs for the web. I am sure that I will return to these foundational materials as I continue to grow and build my skills in this area.
- There isn't anything unimportant that I learned. Getting experience with slowly building up and modifying classes was very helpful. Building classes with appropriate separation of concerns for reusability was great experience.
- Probably unit tests and test drive development as well as the way http works. So far none of the 100, 200, or 300 level classes spend any time in writing unit tests which i think is a major problem in our education. Also there should be some focus on how server and clients work because there are a major portion of real world software.
- I haved learnt Test driven development, pair and mob programming
- How to program in Java
- Programming in Java and network communication.
- Unit testing.
- GWT is the area where I was not knowing anything and did not have any knowledge about it. I really enjoyed implementiing GWT. Project 5 specially took away all my fear from coding Front End.
- REST and GWT were really interesting. They took quite a time in order to understand how they work.
- Test Driven development , Maven Projects ,Servlet ,GWT.
- For me I was in it for learning the web aspects of Java. I have really wanted to learn Spring for a while but it seemed a little difficult to understand without knowing straight Java EE. I am hoping to look more into those things later.
- Real life programming, using a professional IDE, professional tools, and professional libraries. This was the best class I have ever taken at PSU!
- If you could give one piece of advice to someone taking this course in the future, what would it be?
- Don't take this course if you are going to be busy. This class if you are going to be busy.
- This is a course with a lot of programming work, so you need to consider if you already have another one.
- Complain to David until he changes the GWT assignment to an Android assingment.
- Be prepared to spend a lot of time going through all the class materials. It's time-consuming, but it's all very useful and applicable on projects outside this class.
- Start projects early, even if its just getting them set up and taking a look. Also keep an eye on the Google+ group since there is a lot of information to be found there.
- Read about the java standard libraries before the course begins. I think that pretty much all your success in this course will depend on how well you can read java documentation and pick the right libraries for the job. The beautiful thing about java is that it seems like there is pretty much a library to do whatever you need but you just have to know where to look. Also, I would recommend understanding generics very early on. No later than week #2 in the course. Lastly, don't be intimidated by the idea of "advanced" java and talk yourself out of it like you don't belong in the course. The fact of the matter is that you take the course to learn advanced java it's not expected that you are at that level already. I know someone who didn't take the course for this reason. Big mistake.
- Practice using IntelliJ before the class starts and be familiar with the shortcuts and basic of Java programing
- Pay attention to the lectures (and rewatch them!).
- I would say, make sure that the person has a pretty good understanding of OOP in general. I think being able to take this class without having at least been through 300 and 333 is a bit of a reach for some. Granted, there are those that inherently pick things up a bit quicker or have previous experience, but I think finishing 202 and coming straight to a full blown real application would have been a stretch had I already not had the previous experiences both in and out of previous classes.
- Don't slack.
- I feel this is a course which should be enjoyed. The course is so well organized that proper motivation is enough to succeed. Having said that, starting the assignments well in advance can ensure high quality submission.
- Try and dig a little deeper on your own time to figure out how Maven works, it's very convenient to have archetypes provided for you but this will obviously not always be the case. Also, take this class a chance to learn about source control if you don't know it. The incremental development style of the projects really lends itself to the use of source control, and it's such an important skill that many miss out on.
- From the very first project, use TDD on your projects and don't be afraid to refactor.
- Watch the relavant videos posted on the google community and read any relavant posts before starting each project. It will save you a lot of grief, as the problems you will encounter are usually addressed there.
- pay attention to the small details in the assignments, it can be confusing
- Thoroughly understand the code that is given to you to begin with before you start making changes.
- If you want to learn more about java, you will not go wrong with this class. This is one of my best class at PSU.
- Get a Git account set up! Don't procastinate! I did this a fair amount, and there are inevitably always little bugs that come up that you don't expect, and can take a looooong time to fix. Having said that, the pace of the course is good, and there are tons of support resources in place to be successfull.
- Put in a little time every day to your programs instead of trying to sit down and do them all at once
- To start project as earlier as possible and ask a lot of question on the google community. Also work on the IDE a lot before the term starts.
- Don't take this course with 3 other 8 week courses. You'll kill yourself trying to get everything done. It has been one of the most miserable terms I've ever had in school and this is my second bachelors degree.
- Start projects as soon as they are assigned. Embrace the TDD methods no matter how awkward it feels at first.
- Take the time to see and do everything. It moves fast, it will leave you in the dust.
- Bring a jacket to class because the HVAC people make it too cold.
- To really focus on learning JetBrains, Git, and TDD as they are fantastic tools / processes and are valuable in any language!
- Read all 5 assignments before starting any of them.
- Start on the work early, give yourself time to view the past lectures.
- The Java API slide deck is a really good summary of the key methods/fields of the various core language classes. Give it a read.
- Of course, always start the projects as soon as you can. Also, start using Git regularly. Like, in every class for every assignment.
- Start the projects early, come up with basic functionality and then keep improvising if you have time.
- Make sure you can set aside a good amount of time each week to devote to the project and materials.
- Start early on the assignements. Make sure the first couple assignments are really solid, you will use these parts over and over again.
- Use a *NIX-based system.
- Watch the videos, do the koans, go to class, and ask questions! The videos and lecture notes contain vital information, especially for those of us facing a steep learning curve, and although most of the lectures are loaded as videos to the website, I gained more by sitting in class than I would had I simply watched the screencast. The koans are a valuable learning opportunity and should be taken seriously for the learning tools they are. Finally, ask questions! Dave is one of the most responsive, and helpful instructors I have encountered at PSU. His genuine committment to student learning and love of the subject shine through in each interaction, so ask away!
- Really try test driven development. It is okay if you end up getting pressed for time later in the course and give up on it, but really give it an honest effort.
- Eat a good meal beforehand or bring snacks!
- Honestly, be prepared to learn a ton of useful and real world information. Pay attention in class and dont procrastinate on the projects. Also start project 4 and 5 as soon as possible.
- I would suggest the students who are going to take this course in future to have a thorough brush-up on the Java concepts before they start the assignments.
- Don't use IntelliJ on large projects - it slows the computer to a crawl, the program sometimes fails to see your tests, and it can even make other programs timeout or crash due to being such a resource hog. (I was using IntelliJ on a Linux virtual machine on a laptop running Windows 10, for reference.)
- Start the projects as early as possible, they're tricy than they seem to be.
- Go for it.U wil definitely enjoy and learn.
- Take this course and try to understand the concepts, Do not just focus on coding, but focus more on why we are doing coding.
- Try to finish projects well before time. Do extensive testing as the test cases are really thorough.
- You should know all core java concepts , and must practise TDD development.
- Go over the pre-work before the class!
- What made you stay in this course?
- I need it to graduate.
- The projects gave me a chance to explorer many aspects of java programming. Especially GWT was something that I did not know anything about it and introduced me a new way to implement a web application.
- I needed the credits, and the projects weren't too bad. I was interested in learning about the client server project(s) as I had always used other frameworks that did most of the work for you, and I had never really done any UI work.
- I found it interesting. The projects were a fun: challenging because there was a lot of new concepts and tools to manage and learn, but not overwhelming. Lectures didn't include a lot of "fat", just useful content and interesting exercises.
- The class was structured really well. The projects were fun for me to do. Also, the credits :)
- A few things: -Great elective. Java is a fun programming language to use and any opportunity to get better at it is something that anybody serious about programming should consider. -Dave does a really good job at teaching the subject. This is one of the very few courses I have taken at PSU where the teacher actually codes in front of the class. It's really enjoyable to watch the decisions that someone who uses Java everyday makes and then compare how it differs with what your approach would have been. -Mob programming. Well the idea of it anyway. Nobody really stuck around for it and it kinda sucked but it would have been cool if it worked out more than once.
- I was interested in learning Java in more depth and also this is the last elective class I need to graduate:)
- I need the credits to graduate.
- I stayed in this course for a couple of reasons. The biggest being that it was a class where I could actually write code. This is something that goes missing a bit as students transition into upper-division classes. It was nice to have a practical and useful coding class where everything is applicable to the real world in one way or another. The other reason is...because it fills a requirement :)
- I find it easy and fun.
- I loved the course. The assignments were fun and had logical connectivity.
- I think the class was very well paced, and the assignments generally provided an interesting and fun learning experience. They were fair in difficulty and length, and covered a very broad spectrum of Java development.
- I like the subject matter
- I had to choose between dropping this course and the open source software dev lab. I chose to stay in this course because I really enjoy programming in java, and using an IDE for the first time in 3 years was really nice.
- I needed to graduate, also it was good knowlege
- The course is fun! How often do you get to take courses that almost entirely consist of coding? Learning about what the API has to offer and how to handle client/server communication has and will be extrememly beneficial for future endeavors.
- Dave's enthusiasm and interesting projects.
- I love coding! And Java! Plus it was just fun to make programs that did things I could never do prior to taking the course. Projects 4-5 were my favorites!
- Java is my favorite programming language and I want to be able to use it practically
- One of my friend took it last year and said it was one of the best classess in his CS degree.
- I think it is incredibly interesting material, the professor is really nice and knows what hes talking about, and I enjoy learning. Also, I am trying to graduate by the end of the summer, so theres that.
- The challenge and constant coding.
- My desire to be the best programmer in the world!!!! No what it really was simple instructions, great feedback and if you are stuck can get help.
- Java is fun!
- The usage of excellent tools and the focus on TDD, and the desire to get a CS degree. :)
- I thought it was really good practice for software engineering. I feel that is one part of the CS curriculum that is lacking, although perhaps rightly so.
- The assignements are a great sandbox to explore TDD
- Each week I learned something new.
- See question 3. Plus, the opportunity to use object (i.e. servlet) mocks to do TDD.
- I have always wanted to learn Java in depth, and after the first class I realized that this class is going to give me exactly that.
- I really enjoy your teaching style!
- The valuable assignments.
- Java is super important in industry, so it's something really important to learn.
- My desire to learn the material. At times it was hard and frustrating, but any course that explores the engaging, maddening, challenging, addicting, and rewarding world of computer science course will always have those moments. The satisfaction and sense of proud accomplishment after overcoming the obstacles encountered in this course are, for me, always worth the struggle required.
- I am using Java in my internship, and this class is very useful (since I have never developed in Java before).
- It was a course that finally allowed us to do some programming again. Also its a great course learning the features of IDE's and good strategies on how to build our programs. I actually appreciate having to do the plans of attack because it made me think of how to tackle these projects. I think it saved me a lot of time doing those.
- The katas were the most important part of the course where we got to do some pair/mob programing which helped me to think the logic in a better way with the help of my partner/group. This along with the projects given during the course, Dave's teaching style are the main which made me to stay in this course.
- I was interested in learning how to program in Java and how to construct web applications
- I can keep learning things, the materials and projects are a bit challenging for me but I never got frustrated because the instructor always answers my questions actively.
- I wanted to learn new java concepts and revise old ones.
- Instructor's way of teaching and energy definitely.
- The course structure was very well defined. And lot of the things were kinda of new to me so it was interesting to be in the course.
- All the projects were intresting , I found this course knowledgeble.
- 1) Learning web programming with Java. 2) Night classes are good for me (I work). 3) Credits.
- I spend many late nights figuring out the advanced content, but the fact that I was writing professional grade code kept me at it.
- If you had to remove one lecture from this course, which would itbe? Why?
- I found they all had useful information...
- Maybe the very last class because I think there were already a lot of work; no need for final in my opinion.
- The lecture where we had the video about pair / mob programming and David demonstrated pair programming. Why? It was just so boring, I fell asleep in class.
- There was no one class I'd remove, although if I had to pick something to cut out of the course, maybe cut back some of the pair-programming exercises (not all though)? I understand that it's a technique that's good to get comfortable with, and it was interesting seeing the occasional unique approachs some groups came up with to a given problem, but it did seem a little like show-and-tell of a lot of the same code towards the end of the exercises. I'm not sure that's avoidable though.
- The first one. Not due to content since the test driven development stuff was new to me and really useful but all the introductory stuff is always boring.
- The last lecture (the one before the exam). It kind of felt like a lot of what was being done in the first part of the class should have been in 1-on-1 office hours with the sutdents that were having issues. The problem with addressing such specific issues in front of the class is that if everybody else isn't having the same problem it just becomes a waste of their time. However, I will say that I really did enjoy watching you program the game of life. I know I said this already but just being able to watch someone program really builds confidence in the person watching as well. One other thing about that lectures in general that I might change is maybe taking a few minutes to talk about the video lectures from that week and demonstrate how to use some of what was learned in a practical way. A lot of times you read about a library or tool and it's just like "great, now what would I ever use that for." It'd be cool to see it in action.
- we only had 7 lectures and I think tey are all linked to each other and each lecture set the basses for the next lecture. I dont think anything should be removed.
- The Week 2 lecture because I found it to be the least-relevant to the homework.
- I don't think I would remove any of the lectures. I would however, maybe cover more of actual Java (like the idioms and program design) a bit more rather than jump into mob/pair programming as much. I would also try to find a replacement for GWT. Although it shows some concepts that are applicable in other areas, every method I saw is deprecated and it appears it is no longer being used except in legacy code. This might be something to address as technologies continue to advance.
- I would say the first two lectures. Maybe combine both to just one lecture.
- I dont think we should remove anything. More information is never bad. Less information is always worse.
- I'm not sure if there is a particular lecture that I would remove entirely, but the one that was least interesting to me was the one about using Dates. Maybe I just didn't find it useful because I've used it before, but it felt like it wasn't really adding much to the project and was mostly just a refactoring job.
- All the lectures were great - I would not remove one.
- Not the whole lecture, but the first hour of week 7 wasn't really helpful for me. I think working through problems with project 5 went more smoothly over the google hangouts.
- i would condesne the first couple of lectures, since most people here know java or a OOL, and put more into the web API, or add andriod material.
- One of the core API lectures went super in depth about file I/O and became very hard to follow. I can still see why it is important to cover though and who knows, maybe I'll go back to that video in the future.
- I think they all were pretty valuable, so they all should stay.
- I don't like the JUnit very much and I found that I don't use it much outside of the class so I'd probably take it out of the course.
- To me, if lectures involved materials that were used for projects, I was all for that. The topics that had little to do with our projects were difficult to stay on top of, as I know I learn best by doing (a.k.a coding the projects, mob programming, koans, etc)
- I don't know about removal of a lecture so much as removal of kata.
- I am not sure about his one but I would say maybe the 1st lecture about project 4 because in the next week's lecture was had more insight about the project witch made it redundant
- None of them.
- First one.... I am a grown up I dont need a readthrough of the syllabus.
- Reflections. It was interesting, but didn't seem relevant to the current assignment.
- Honestly, I would remove GWT as a whole from the course. It would be better to create UI's using JPanels and the Swing library to use Java where it belongs - native applications. JavaScript is a powerful, beautiful, expressive, dynamic, functional programming language and frameworks like Angular are far better suited to web application development. Keep Java on the server-side, sure, but it has no business transpiling to client-side code for the web browser. It has been said that using GWT to write client-side code is like trying to play the piano with boxing gloves on, and I think the sentiment is precisely accurate. There's a reason why GWT is dead, and why most of the members of the Google GWT team moved to Angular! To embrace the best technology for the job. Just my 2 cents.
- The first one, the first day is always the worst.
- The GWT lecture. If i were to create a rich web application, I don't think Java would be the first tool I reach to.
- None. I liked the lectures.
- Maybe the Classloader/Reflection part of the Reflection lecture slides. If we used that technology either directly or indirectly in any of the projects then I'm still unclear on how/when we used it.
- Week 7. It seems that we didn't really do anything except look at errors.
- Probably just the first half of week 7 lecture where we took a look at a few specific issues students were having with Project 5. At the time, I hadn't had a chance to begin seriously digging into Project 5 and the discussion was too specific to be of any use to me.
- Some of the lectures in the middle of the course. I think going over the details of some of the online material would be more valuable.
- Not really any.
- I would remove the working with files lecture. If people have taken CS202 at PSU then they have already worked with files.
- I would highly suggest that the final project be modified away from GWT. I can't imagine many people or companies would use GWT over JS and the frameworks that one can use for front end development. I think the best alternative would be an Android app for the AppointmentBook program.
- Not really a lecture but all of the time spent on pair/mob programming. After the first couple time i think it lost its benefits, meaning I didn't learn anything new. I think the time would be better spent have more a lab environment where people could work on projects and have discussions.
- I feel like there is no lecture that has to be removed from this course. I feel this because, the course flow is in a proper way, starting from the basics to the advanced concepts introducing the fresh concepts one by one gradually. So I feel like this flow shouldn't be missed by removing any lecture.
- Introducing us to pair programming. While I felt like getting practice with pair programming was good, the introduction video seemed to state a lot of obvious things that pretty much boiled down to "be considerate and take turns."
- Dependency Injection
- I dont think any.Everything is just appropriate.
- The third one probably. First lecture was important as it gave a basic idea about the content of course and expectation from students. I think second and third could have been clubbed and rather DI should have been covered in class more.
- I haven't had time to go through Dependency injection.
- Lecture 7 as I found it was repeatative ,gwt concepts we learnt in lecture 6
- The first one. I didn't find the setup information too useful. I don't think there is anyway to get around that though as everyone needs to be on the same page.
- One less coding Dojo. Awesome class Dave! I cannot thank you enough!!!