Previously on CS410J...
Another large batch of students had a lot to say about Advanced Programming with Java
- What do you wish you had known before taking this course?
- Before taking this course, I wish I had some networking knowledge. Had I known even the very basics of networking, I would have been able to complete project4 alot less painfully.
- Before taking this course, i think prior knowledge of java and junit in required.i had basic knowledge of java that helped in doing all the projects.
- How to work with build tools. I'm still a little mystified by how Maven works and feel like I'm just memorizing commands without really understanding the big picture.
- How time consuming some of the project is but when you get it done, you kinda feel proud of yourself.
- I wish, I had known Test driven development before taking the course and i found it hard to match up to the speed of my peers while using it in first couple of projects. Had i known it before or practiced it before I would have done a better job.
- For projects, I faced difficulty in recalling the basic concepts of Java. So, I should have brushed up those concepts before the commencement of this course.
- Aside from knowing the APIs that we used for the variuos projects, I don't think there's anything that I could have known that would have helped me helped me succeed further. There was a lot of documentation reading on my end because I wasn't familiar with much of it, but other students' mileage may vary.
- The exact scope of the course, and meaning of "Advanced" in Advanced Java. Granted, this is probably information I could have found if I did more digging; in truth I picked the course in the order of fitting my schedule and then the one that was the most appealing among those.
- Nothing I can think of.
- I think I would have been better prepared for this course if I had more experience with IntelliJ, or any other IDE, for that matter (as the PSU CS core generally restricts you from using an IDE on projects). It was not that IntelliJ was difficult to figure out, but I'm sure there were many features of the IDE that I didn't know about that would have been useful in doing these assignments, such as code generators, attaching a debugger to a remote process, etc.
- My Java skills were not great. I probably should have been a little more comfortable with Java going in to the class. I've had plenty of c/c++ programming, so it wasn't too bad to pick up.
- Knowing something about HTTP and GWT would be helpful, but it is not that critical
- I already had some previous experience with basic Java so there was really nothing I wish I had known before taking the course. I felt a good background on basic Java was enough to enjoy this course.
- Client-Server programming, some exposure beforehand would have reduced time taken to implement solutions.
- I wish know the Java language better. I fell like I used the old programming way that was used in CS263, and CS202 for the first two or three projects. Towards the end, I got more familiar with Java.
- Knowing java beforehand would've helped.
- The amount of time required each week for projects.
- I was not familiar with Web programming prior to taking this course. However, I had sufficient time to get acquainted with the concept. So, nothing.
- That the quizzes are open notes
- A good basic understanding of Java concepts is needed which I have. I wish I knew more about applets and GWT which would have made my project life more easier.
- More about the web and GWT
- I read the course website before taking the course and hence there really weren't any surprises. I really enjoyed the course.
- It helped that I was familiar with REST, but if I was not, I could see that as being helpful knowledge prior to the course, as that system of programming is pretty difficult to grasp at first. Otherwise, I feel the class was extremely beginner-friendly and could really take someone from having a basic understanding of Java to being a competent Java developer.
- I wish I knew some of the functional programming stuff that popped up a few times during the course. For example, in the Java Koans assignment.
- A bit more about Maven and java configuration in Intellij.
- I wish I had known more about the tools that we used in this class in general, including github and Travis CI.
- There is nothing I can think of that would have made it any easier. I mean, short of just knowing all the class material from the get-go, I felt prepared to take it based on what I knew from previous courses.
- I wish I would have known that we were creating a web service prior to taking this course. Since I knew little to nothing about HTTP protocols and interactions between a client and server, I think I would have read up about it beforehand.
- I think overall I was pretty well prepared for the course. I had worked with Java before quite a bit. I do wish I was more familiar with the Java way of setting up servers. I think the web/REST API part of this class was one of the best parts because that usually can have real life applications as web is becoming essential to our daily lives. I do not really feel as though there was necessarily one specific thing(s) I wish I knew going into this.
- I wish I had been experienced with MVN in order to make use of all the cool features.
- GWT. I already had experience with most of the material in this class from my job except for using GWT.
- That all the class I created have already been created by someone else. Learned that late in the term; such as my time and date class.
- n/a
- How the assignments are graded
- I wish I had known a bit more about the busy work and that we would be working with Web technologies, that was unexpected.
- Maybe a little more Java, but more git(Pull Requests, etc.) and Maven knowledge would have help me be able to focus more on TDD and the Advanced Programming ascepts of the course.
- That it is going to have above average work load.
- How the internet works. How things are submitted through the internet with request such as post, get and etc.
- I would have liked to know more about maven and the other project management tools used in this course beforehand, since they seem like big topics.
- Maybe just a little bit more Java knowledge. I spent the first project spending time relearning Java. It's better than not knowing any Java at all though!
- More java; How much of a time sink this class would be; Why taking 3 classes in the summer is bad for you
- I wish I am little more stronger in coding about Client and server coding, and know a little about GWT.
- Rest API and more about servers
- I wish I had some Maven experience before starting this course. Most of Maven's magic remains a mystery to me.
- How much time it takes to make a basic GWT interface. And also the virtualized JRE for testing out the GWT interface has a lot of core functionality missing, such as SimpleDateTime >(,which was a pain to work around.
- I wish i was more versed on Maven, but I caught on quickly. I guess git as well. But overall, I felt fairly prepared.
- How a client/server works
- I wish I had more experience with IntelliJ's IDE, it seems like making use of the IDE's functionalties like extracting a method or auto generating code is useful. the stuff you show during class is great. Mabye next time you can go into that more during class demonstration.
- I wish I had known more about software testing, maven and some of the more abstract java concepts, especially with regard to using testing tools like mochito as well as the reflections api. I think I was a bit overwhelmed by the volume of material covered. I felt that these topics were important but my understanding of there utilization is still not what I'd like it to be .
- I wish I would have noticed it was only an 8 week course, I thought it was longer.
- about maven and Test driven development
- Nothing really. Topics were introduced at a good pace.
- Web development
- know more about using the tools in the industry
- What is the most important thing you have learned in this course?
- I have learned alot about test-driven development, specifically how to write automated test. I have also learned alot about the various java APIs, which is very helpful to know.
- The most important thing i learned in this course is Test Driven Development practice which is widely used in software development. Proceeding with test cases preparation and then code according to them reduces the time of developing code and are less prone to method failure, Besides this i also learn pair programming which i had no prior idea.
- The importance of writing thorough tests. It was also great to get more experience with intelliJ's debugging tools.
- I think everything I learned is important but I think TDD is the most important one. It later got hard to use for proj4 and proj5, but overall I'm glad I got introduced to it. It helped with my programs a lot.
- I think the Advanced programming in Java course had lot to offer as far as the learning goes and was truly value addition. The programming practices such as pair programming and test driven development was truly a great learnings. In addition to this advance programming in java especially in project 4 and project 5 led to learning about REST api and google web toolkit that according to me was important thing to learn.
- I have always wanted to learn about Rest API and this course helped me gain the basic understanding of how the Rest API works and how the client and server interact using it.
- I'm not really sure where to start. Learning APIs will save me a ton of time in the future. Maybe the client/server stuff? I haven't done much of that (yet) in CS here at PSU. Really, I think everything in the class is important and seems applicable to Java programmers in industry.
- Probably how Java can work with web stuff and asynchronously. The first half of the course was already fairly familiar, but the second part was interesting and I learned a lot. Even if those particular technologies are dated, they are mechanisms I'd never dealt with before, and the novelty of that made them worth it.
- The model of Test-Driven Development. I learned to force myself to code in that way and I began to understand why it's important and common.
- The most important thing that I learned in this course is that I'm actually better in Java than I thought. Rather, the background in C++ that I got from the undergrad classes at PSU prepared me much better than I realized to pick up Java, especially with the help of an IDE.
- TDD is great, but I think my favorite/most important thing is working with client/server applications and apis. It's something I've been on the fringe of, and now I feel more comfortable with the content.
- One of the most important things I've learned is I started to be involved in web development since I haven't done anything in this field before. I understood the basics of HTTP requests and client/server relationship. I also learned how to create a UI with GWT which was also very useful for me.
- How to use all the tools and methodologies that we were introduced to, like IntelliJ, Maven, Travis, GIT for source control, TDD all of which I feel would be super useful for us in the future if we are to work in the IT industry.
- Pair programming and test-driven development, especially latter. The crux to figure if implementation was headed in correct directionm, was to write tests beforehand.
- Unit Test!!! I have never written unit test before this class, only heard of it. I feel like unit test is super useful in so many ways.
- Writing unit tests and integration tests.
- Getting familiar with the core Java API, exception handling, and test driven development.
- Pair programming and test driven programming. I liked the hands-on experience.
- Practice writing code in Java and writing junit tests
- I would say Using of Maven is the key thing i leant which helps in the Software world really well.
- Integrating Java with web applications.
- I wanted to learn Java and comfortably code in the language. I feel I have got a good hang of the language, the various data structures in it. I have learnt Test Driven Development to some extent and have learnt to appreciate tools like Intellij, Git and maven.
- Learning about modern programming techniques. Other classes really only taught programming used in the 70s, like command line programs that just run a main function. However, I learned about event-based programming and asynchronous call-backs which are necessary for modern web development.
- The most important thing I learned was how to write unit and integration tests.
- That would be a tie between TDD and creating a REST based service.
- I think working with an IDE is the most important thing I learned in this class. I am accustomed to working with vim so this was a nice change.
- Hard to say--it all seemed valuable. I think that becoming more familair with the Java API gives me an edge in learning other similar languages, but probably the REST and GWT implemetations (in terms of using their APIs) were the most valuable. I could also throw in TDD.
- The most important thing I learned in this course is the importance of abstraction, and also it has been nice seeing how important Java views this concept. At first, I didn't like how many classes and options there were for a single behavior, but understanding the onion analogy, I can see how useful it is.
- I think the two most important things I learned from this course were about testing and web. I think the more and more I code and work the more I realize how important testing is when you are creating a project. Before I didn't really know how to write or create tests in Java and now I feel like I have some sort of understanding. I also believe the web/REST API part of the course was also something important I have learned. Taking a Full Stack web dev class previously at PSU helped me a lot during this portion. I think more of the course could comprise of web related stuff (except GWT).
- The practice with API's was actually super helpful! I've been working a developer internship over at Viewpoint Construction Software and have had to work a lot with various C# API's. PSU unfortunately has not given me much experience writing server side code so your class was extremely helpful for that!
- The mechanics of test driven development.
- Using test driven development to write code. Its really slow, but flawless; well, still has issues if you don't have the right test cases. That being said, to also start as early as possible. And watch others code to get a different view
- The importance of refactoring and testing as you go. Despite being slower, the pain is much less when you suck it up and fix things as they emerge, instead of "later".
- REST
- I think the REST API stuff is invaluable in a work environment, so kudos for teaching it. (could've spent multiple weeks on that I think.)
- TDD methodology and Maven - from an industry point of view. From a programming point of view, the large amount of time coding was most important for me.
- I think my basic concepts of java improved a lot with this course ! I knew OOP with C++ but had never worked on Java except for small assignments. With this course I can definitely say I am not a beginner in Java.
- The most important thing I learned from this course is how the backend and frontend of a website.
- Test driven development
- Test driven development, mock objects, server debugging. Overall a lot of the testing stuff I found very valuable. I'm definetly going to be taking these testing techniques and using them in my other classes.
- GWT and the REST interactions for Project 4 & 5 were both challenging but gave a good base-point for how people use stuff likfe Java in the real world. This is something I need to learn if I plan to be a professional programmer.
- I have learned client and server coding, GWT, handling errors, developing a small web tool and many coding related lessons.
- All the different things you can do with Java
- How to adopt/practice pair programming and test driven development. The coverage of these topics in my other courses was insufficient.
- I actually got a fair amount out of this class, from a basic introduction to TDD, to a better understanding of RPC style communication with a server and REST. Having this project slowly grow over the term was nice as well. Learning to work in old code that wasn't initially intended to do what the later projects needed is a normal part of a programmers life.
- The most important thing I learned from this class is that I need to start earlier on my assignments. I left a lot of assignments off until the last minute and they ended up taking longer than anticipated and I paid for it. I didn't lean as much as I could or should have because of a lack of discipline on my end.
- How a client/server works
- Alot of stuff. But I think learning about writing unit tests and integration tests was probably the more importhing that I have learned
- I think the idea of red grean refactor is probably the best thing conceptually. I find it takes a lot of self discipline, but it seems to save time in the end. As far as specific java conepts go, I think being able to manipulate and search files was pretty cool, I also like working with web APIs. Even if they are outdated, they are still useful. I also thought some of the techniques for sorting and data structuring were up there. Also learning to code to the interface. I used to do the oposite.
- To really focus on test driven development, it definitely helped me keep on track and breaking my projects up in to smaller pieces
- I got to know that designing an application with good documentation is very important. Learnt a lot of coding techniques and achieving the modularity.
- Probably test drive development.
- Unit Test
- the unit tests
- If you could give one piece of advice to someone taking this course in the future, what would it be?
- Don't be shy to post stuff on the Google+ community.
- Start the project early! They seem straight forward on paper, but there will always be some weird bug that wil get encountered. Also, reach out for help as soon as you need it, don't wait until the last minute.
- The course is purely industry based and all the topics covered in the syllabus are much use in industry which will help in professional life.
- Budget your time wisely. This class is more demanding that you expect it to be.
- Start on your projects ASAP.
- As I already mentioned TDD is the big thing in the industry and apart from the big fours the other firm are also using it. This course has lot to offer if you want learn how Test driven development works as the professor encourages you to do so (although not compulsory) is if you could a beginners experience on working with TDD then it would really help.
- As I mentioned before, one should brush up the basic Java concepts before taking this course, which would help in understanding the classes and doing projects easily.
- Set up your environment/path/etc as much as possible before you start class. I spent so much time tinkering around with that so maven would play well with my IntelliJ. Nothing is more frustrating than having to beat a minigame before I can actually start to code.
- Honestly, strike a good balance between asking questions and not asking too many questions. Thus far, the only score I've lost is due to a misunderstanding I didn't correct until it was too late. I could have asked about it. However, some people ask questions about every little thing on the community, and it's difficult to believe these aren't things the person could answer or find on their own - I think asking for that level of spoonfeeding inhibits the learning process to an extent (though this is just my take, and of course since I can't see into their minds I can't accurately judge anyone else's level of ability) - but I've always believed that struggling is part of the learning process, and it feels the ability to ask so many questions may have hindered that some. I also feel like maybe I'm getting a bit off topic here...
- Stay on top of the "before/after lecture" videos, and reading material. Oh, and bring dinner/snacks to a 3-4 hour evening class!
- Set aside a little more time than you initially plan to. Learning TDD is a great experience, but it takes some time.
- Don't stress out and enjoy this course!
- Well, to have a good background on basic Java and OOPS. And to be ready to spend some quality time on the projects just in case you have other plans too along with this course.
- Definitely take this course, the very fact that it is hands on programming, is exciting. Piece of advice would be to get an early start on projects.
- Make some time for reading the pre-class materials.
- Discuss every aspect of the project before beginning and understand exactly what needs to be done to avoid any confusion.
- You may want to go half time this term, or take this class by itself, unless you're already fairly proficient in Java.
- Starting the assignments before time gave me sufficient time to test and try out different approaches.
- Pay attention to the assignment, there seemed to be a lot of confusion about what the required behavior of our programming assignments that I think were answered in the assignment.
- Learn Java basics and applets. You are good to go.
- There could be a lot of road blocks depending on what machine you're using, dependencies missing, etc. It's good to start projects early to prepare for those types of issues that prevent you from even starting to code in the first place.
- Start projects early in the week and do not hesitate to ask questions. Most of your questions will be answered in the course website. We just need to look in the right place.
- There is a ton of information that is taught in this course, so it is important to set aside a lot of time to watch the all of the screencasts. Also, don't feel shy about asking questions on the googleplus page as there will inevitably be things you won't understand fully and should clear up asap instead of spinning your wheels.
- Get familiar with Oracle's Java API documentation as soon as possible.
- Make sure to watch and read the instructional Java content on the class webpage: it's very concise and will help immensely in projects.
- Definitely watch all of the screencasts! They make a huge difference in what you get out of the course and how prepared you are before going into each project.
- My advice would be to take the course as early into upper-division as you can. It is a great course--I wish I had taken it a year ago. Using git and maven and other tools would have helped me throughout the last year.
- One is so hard! It's between start koans early and write tests for your projects.
- Well, firstly I would recommend that you know Java. Whether you are an expert or novice with Java I think that is still ok. When doing the projects make sure to design them before jumping into the code, make a good plan of attack! Also brush up on your web stuff and read about REST API and other important web related stuff.
- Go to the google communities it's a great resource to get better understanding on the assignment and the expectancy
- I would advise them to start projects early in order to have plenty of time to really engage with the project.
- Keep track of the due dates for the multiple pieces of assignments (POAs, surveys, quizzes, koans, projects, etc).
- My once piece of advice would be to watch all the videos and write down notes. They're really helpful and are jam packed with tons of information.
- ABSOLUTELY get to work on projects the day assigned. Ask Dave / Google+ comm lots of questions. It's very easy to get yourself mucked up on a bad setup of your coding environments and not realize until late in the project. Totally screwed myself with a bad set up of project 1 and felt behind all term bc of that rough start.
- there is a lot of busy work
- read the assignments multiple times, because they are a bit vague with obsured details. Be prepared for a lot of work, but a really good learning experience.
- Review git methodology(not just simple git commit and push/pull). Understand Maven well. Get some up front experience with IntelliJ(short cuts, etc.)
- Its a lot of work so get ready to give it your best but you will learn a lot because of that.
- Keep your code as clean and flexible as possible, you will be re-using it a lot!
- Even though you aren't graded on if you did or didn't write tests, definetly build your programs with Test Driven Development in mind! It will save you so much time. When you finish your programs you're conifdent that they work without errors, and you can run all your tests with one quick command. It also comes in handy when you know your program works on your machine, but need to quickly test it on the department Linux machines.
- Take the amount of work you think it'll take to complete a project, in solid workdays, and double it. Double it again if one is seriously considering building out the projects in TDD.
- Be strong in foundations, so that you can learn a lot in this course without any work load, tension etc. This is a course where you implement everything what ever you learn, so you will complete this course with total satisfaction.
- It's going to be a lot of work, but usefull information so try and really learn the material
- I would advise new students to read/watch a Maven tutorial.
- Learn to work around the code you supply so they can keep maven happy. Honestly that part of this class really annoyed me.
- One, piece of advice, start assignments early and code everyday.
- Take advantage of Google+ forum or any other forum you can get help in.
- Make sure that they have the alotted time to really digest everything and learn why they are doing what they are doing.
- I would say follow along with the in class videos. I thought it was a good idea to note the time when important things were being said. I would also say find someone in the class who knows stuff, I got stuck a lot and it felt like I was sort of on my own. I probably should have used the community but much of my problems were just silly mistakes that I couldn't find for a while. I didn't feel it was appropriate to post my code for a second set of eyes, not only because it's embarrassing, but also it's probably not permitted.
- Always start your projects as early as possible
- Familiar with Unit testing and JUnit framework, writing your own test cases and familiar with maven.
- Get really comfy with the Java standard libraries to make your life easier.
- learn Java beforehand, this is not an introduction to Java course
- read the assignment carefully. Thinking on the side of user.
- What made you stay in this course?
- I liked the way each project was designed. It made us learn different aspects of Java and that's what made me stay in the course.
- I really appreciate being taught about practices and methods that are actually used in industry. This course has taught me many practices that are used in undustry, which is what encouraged me to continue the course.
- The course content and projects as homework made me to stay in this course.
- It is a skillset I wish to develop. I am hoping to work for a company that primarily uses Java.
- I stayed in this course because I wanted to challenge myself.
- To be honest, this course was a lot of work as we had to submit POA, quiz, project almost every week. But what kept me going is the work to be done had lot of learning as I had just worked on core java before never used tools such as Maven and the IDE Intellij Idea. In addition to this the policies by the professor which allowed us to re-submit the code if fail to score well in first submission kept me going as while re-submitting i got to know my mistake and got an opportunity to correct them as well.
- I wanted to learn concepts of Advanced Java and I really liked the way they were presented in the class and that made me stay in this course.
- It felt like what we learned would be valuable in industry. The course is entertaining and thought provoking. The fact that I looked forward to class on Wednesday nights (seriously).
- The fact that it's my last term and that I was already decently prepared for the course would have made dropping it the worst possible decision I could make. Especially given the tremendous workload my capstone course has been - so much work has needed to go into that that I'm grateful I only took one other course, and that it was one I was decently equipped to handle. And, incidentally, I feel like the tone of this survey thus far has skewed towards "this course is too easy" - that's not my intent, nor to brag about my own ability - I think I addressed in my midterm survey that I feel the course might be better named "Fundamentals of Java" rather than "Advanced", and I still wonder if that wouldn't be a better title. I certainly don't know all there is to know about Java, and I definitely benefitted from my time in the course. But I don't believe the curriculum to have been at the Advanced level. I do believe it was necessary, and I wouldn't change the content - just the name. I'm getting off topic again. Sorry.
- Knowing that Java is a widely used language in industry, I felt pretty motivated to learn and practice Java skills, and the projects in this course kept me quite motivated (especially the speed at which they were assigned/due!). The material was interesting, and the projects gave me experience in working with technologies that I will surely use in the future. Oh, I guess the instructor was kinda cool too... haha :)
- I enjoyed everything about it: the content, the process, the classes, the professor, and the outcome. Hard work pays off.
- I wanted to learn more about Java. Usually, PSU courses are limited to basics of some programming language, but here I learned something that is close to industry standard and I like it.
- For me what makes me stay in any course is the teacher who teaches it. So yes I loved the way Dave approached the subject , specifically focusing on TDD. I also had lots of fun doing the projects, the last two being my favorites.
- Course content and Prof. Whitlock's teaching skills to keep this course exciting throughout the quarter.
- I like web development. I have never written any web aliication before. I know this is a simple application but it is a good start. We were gievn handful information, a lot of the stuff in the project we have to figure it out on our own. It is challenging but fun.
- I was getting to learn a lot and projects were fun, and I wanted to learn java.
- Two things: 1) I really wanted to get used to coding in larger projects, and improve my code speed and thinking. 2) This is the my last required class for graduation, and I don't want to come back for another term.
- Like I said earlier, rather than just teaching the concept, having a chance to experiment is what made me stay in the course.
- I liked this class. I need practice actually programming and I like that we got practice writing code and writing tests.
- Flow of the course is quite well arranged. The course content really impressed me.
- I like Java and also I need the class.
- I like the industry-based knowledge about coding methodology that you impart.
- The projects and course material were extremely relevant for adequately preparing myself for a career in software development. These are techniques that you would either learn now, or have to learn on the job, so it is nice to be able to be familiar with them now instead of later.
- I felt like I was learning valuable skills and the course's difficulty was set at the "just right" setting for me.
- Solid content that will be highly useful in the work force.
- I stayed in this course because I felt comfortable with the material and knew it would be good to gain some experience with the tools that we explored in this class.
- I had never planned on leaving? I don't know what you mean. I signed up for the coure, and I took it.
- I like finishing what I start, and I enjoyed the course.
- I think it was the challenge of learning and building something new every week that kept me going. Was it frustrating at times ? Yes. But I knew it is going to help me a great deal.
- I stayed in this course because I wanted to expand my knowledge of Java and get a better and bigger understanding of the things Java can offer to me as a developer. This course also offered me time to proctice my Java and perhaps improve it somewhat. I can definitly say I have learned a few nifty things, things like from the Koans project, and the Web part of the course.
- I loved how much actual programming there was!
- To get the course credits.
- The lectures and wanting to learn about java
- Great content. Fantastic teacher.
- Graduating on time
- Its a great course. Why would I drop? (Plus I graduate this term...)
- Getting an industry perspective on coding practices as well as coding time.
- This class has helped me understand and learn new libraries and taught me the server and client side of a website.
- The topics covered were very valuble to me.
- Originally it was because I needed a 410P course in order to take the capstone fall term. As the term went on I really enjoyed how we were using a lot of tools and techniques to help us code. Learning about build tools, IDEs, and testing are all very important topics that I'm sure will come up in industry. I would recommend this course to anyone interested in a job in Software Development, or similar areas.
- Honestly? The credits. At this point in the degree, I'm so close to being done that I don't care about the grade as long as I get exposure to new things that could help me professionally and get a passing grade for the course.
- The course itself is very useful. Moreover the way its thought, in a very interactive way, the way everything discussed is implemented so that we learn everything etc made us stay in the course.
- Information seemed valuable compared to other Electives at Portland State.
- I stayed in this course because I needed more CS elective credits for my degree. The Java projects were enjoyable and interesting. They were the most rewarding aspect of the course.
- Besides needing the credits? I wanted to see what sort of tools Java can use for web based services. The last 2 projects were fairly educational for me.
- What made me stay in this course, is that learning is fun and when I was coding and working out problems I was having a great time.
- The credits I get for it.
- Mostly because I wanted to do more programming using IDEs. Get experiences with source control like GIT. And to also learn about other programming practices like test driven development.
- I really want to graduate asap, also I stuck around because I wanted to do the web stuff, I find that really useful. In my branch of study working with embedded systems, the web is really useful for running remote systems. For example you could take an esp8266 wireless module for 8 bucks and attach it to almost any sensor and upload the information to the web it has GPIOs on it as well so you can act on this data by hooking them up to whatever you want, switches or BJTs or other more powerful processors, even robots. All through the web.
- It was nice to get a better understanding of Java (which is relatable to other languages)
- The projects.
- Good instruction and modern topics.
- Can help me practice Java
- The constent is interest
- If you had to remove one lecture from this course, which would itbe? Why?
- Probably the second dojo session, while the first sesssion was really helpful and interesting, I feel that there wasn't anything new to gain from the second session. I would have preferred to cover another coding technique, or something new instead.
- To be honest , i am not sure which lecture should be removed ,i found all the classes very helpful
- I don't feel like I gained much from the coding dojo exercise. Perhaps this works better with a smaller class / fewer students?
- Probably the first day.
- I think the overall course was very-well structured and none of the lectures were unnecessary and every session i have attended (or watched on youtube) was fruitful and a true value addition.
- I liked the flow of the lectures from Week 1 to Week 8. So, I don't think that any of the presented lectures was irrelevant and needs to be removed.
- I felt like they were all valuable. Towards the end though, it felt like the lectures were more assignment Q/A than learning new things. Which is totally fine, but you may lose some students' attention if they've already crossed that bridge. One thing that may help in the future would be to pick one kata and stick with it through the term. I think if we were able to concentrate on minesweeper (for example) for an hour or so each lecture instead of bouncing around with several kata, I would have gotten more out of the pair programming exercises.
- I don't know how to answer this because they're all pretty brief. Instead, I'll say I would remove the pair programming/code kata aspects. They teach important things, like programming as part of a team, working with git, and so forth - but I think those elements are worthy of their own course(s) and detract from the potential otherwise possible in Advanced Java. This is difficult for me to say, though, as I've taken the course once, and you've taught it several times. I can imagine the curriculum is here because you deem it necessary, given your experience, and I'm not questioning that judgment - but I personally found them to be disappointing because of the thought that their inclusion necessitated the exclusion of more advanced concepts and materials.
- I dont know about removing a lecture, but I maintain my opinion from the midterm survey that I think I would have benefitted more from having the screencast and lecture materials reversed. Personally, I would have liked to have gone through core concepts and seen examples of how they worked in class where I could ask questions, and rather have material on what a Coding Dojo, or a Code Kata was as a video I could watch outside of lecture time.
- I hate to give a non-answer, but I wouldn't remove any of them. Some may have had more "exciting" material than others, but I found plenty of value from each.
- One big Kata lecture, I think. It was good to try something like that, to see who everyone can work on one GitHub repository, but I don't think it works for the format of this class. Mostly we were stuck on basic functionality, not going any deeper on the actual design of the project and most of the people were jsut waiting for the main pair to get done.
- I felt all the lectures were very useful and organized perfectly aligned with the projects. I would not suggest to remove any of them.
- I didn't feel any lecture can really be omitted from this course!
- Not really. I think this course is well design. Each lecture provides some information we will be using in the next step
- The Katas. It was slow and not much fun. I learnt more watching and listening you work than working on Kata.
- I would remove the GWT module entirely and replace it with a module on Android development.
- Nothing as such.
- I have a hard time learning by watching web videos. They are a good reference to have but don;t work well for me as a primary source. Therefor any lecture that wasn't directly related to an assignment went in one ear and out the other, even though for example function programming is very interesting to me and I have plans to revisit if I can find the time.
- Too much of katas/pair programming happened is what i felt. May be 1 lecture in that could be removed.
- None, I feel like they were all good material to know.
- GWT. Since it is not being used today, I feel it would be better to replace it with some of the web technologies that are used today.
- The first lecture. There were too many bugs and issues with getting set up.
- I didn't really enjoy the lecture where everyone was pair programming for the tennis kata. Personally, I can't concentrate in such a noisy environment where everyone is talking, so it wasn't a very productive experience for me. Also, it seemed like most of the time my partner and I were trying to figure out how to do what the program needed, when in the real world, you already know what approach to use and one person drives while the other navigates (you aren't really brainstorming what code to write, but rather, to write well-written, sustainable code). However, I do think the intention behind the exercise was good, just not implemented as well as it could have been.
- The lectures where we did pair programming. I really didn't get much out of them to be honest and I think the time spent on pair programming could have been better spent with the standard lecture format.
- I'd remove the coding Dojo: its a bit too hard to manage on a class room scale (keep the videos though, its still good to know about).
- In general, I think the paired programming aspects of the course were a little contrived and difficult for me to take seriously. I think it is hard to pull something like this off well though, so given this constraints, perhaps it is the best we can hope for in terms of paired programming experience within a classroom setting.
- I would not have removed any single lecture, but I would have spent less time on the mob/pair programming topics. I think they are valuable to cover, but keeping pairs of people organized in class seemed untenable.
- I couldn't think of one! I thought they were all helpful, especially the TDD lecture, and the lectures where you went over debugging and the last projects.
- None really. I thought they were all relevent in some way to Advanced knowledge of Java.
- It's kind of difficult to say which lecture specifically, but I would kind of drop the lecture and project that has to do with GWT. Previously working with other web technologies I found GWT clunky and a little awkward to use, it also seems like it is a bit outdated and I think there are better technologies out there (but they do not use Java). I would instead probably expand the REST API/Jetty server lecture and perhaps add more things to it like maybe a backend database so it is persistant. Apache Tomcat also look pretty intresting.
- I would remove the coding dojo as though it was fun, I didn't find it very useful...
- Pair programming, mob programming, coding dojos. While the idea of making the class interactive with these exercises, I don't feel like it really engaged the class and I didn't learn anything from doing the exercises that couldn't have just been described. The class time could have been used to go over other concepts instead.
- That's a tough questions, because the lectures were different in their own way. The coding dojos are awesome, along with the pair programming. I wish one of the assignments was a pair programming assignment
- n/a all lectures as posted were relevant and helpful.
- gwt because it seems like it's old technology
- Mob programming because I don't think it works great in a classroom environment.
- Not sure. Since this was a "flipped-classroom", having the lectures on YouTube make them all useful. As far as the in-class time, I had trouble keeping up with the live-programming excercises. The pair-programming and mob-programming was helpful though.
- The test driven development was necessary, but I felt that it was dragged on for too long.
- We went over pair programming and the like for a bit longer then was helpful I think.
- Honestly I found them all to be good. If I had to choose one, I would pick the Functional programming slides and screencast. It's not an in-class lecture, but I found that I really didn't use the things covered in that topic much, besides in the Koans (And even then, just a small bit!)
- This one is hard to answer because I'm more feeling like asking what other lectures could happen that would improve my understanding. If there were problems with the lectures, it was one more of how everything was compressed to fit the time period.
- I don't think I could suggest any. I felt each and evry lecture is useful in its own way.
- GwI, maybe try and replace it with something that is not as outdated. Web Dev was very useful but everyone online said it was old and outdated so we should probably learn something that is still used.
- I can't tell if this question is referring to the in class lectures or the old screencasts/slides. I would have appreciated an in class lecture on Java's more exotic features.
- Pair programming, because I still don't buy it as a useful practice. Just sitting there asking someone what to write while the entire class stares at you, is kind of useless in my opinion.
- A lecture that wasn't useful doesn't really come to mind. I found them all equally relevant and applicable to the course.
- Maybe some of the API stuff. I knew a lot it.
- The katas and the dojo thing. That's just me. I learn best by doing those type of things by myself where I can think and code throught the problem. Pair programming demo in class is good.
- I don't think I would remove an entire lecture just bits and pieces. But in general all the information was useful. Some of the topics I think had too much time spent on them and others not enough, I would have liked to have spent more time on gui stuff, I thought that's what java was known for. I also think it might have been good to spend some class time comparing our project code. I was never sure I had done anything correctly or if there might have been a better way that I missed. Maybe just show us what you would have done.
- Honestly probably the GWT stuff, but I only say that because I have worked with over RIA frameworks that I personally prefer more and that are more advanced. I like the idea of perhaps using Android in the future, I think it is a little more relevant and a good reason Java is still used as widely.
- Core java lecture of week 1. I felt it is very basic.
- Probably the coding dojo one.
- GWT, it's out dated.
- I will replace google webtookit with javascript and html