I am trying to connect to a broker that is using FIX 5.0
I would like to leverage quickfixj for ease and speed of implementation.
Is this going to work? I am assuming 5.0 extends (so to speak) the features of prior versions, but I do not want to get too far along and wind up causing more issues than it is worth to use quickfix.
I ask this because the current website says that quickFixJ is okay for versions of fix between 4.0 and 4.4.
Will this still work with 5.0?
Many financial institutions use quickfix and it is quite likely that if QuickFix has an issue with version 5.0 the other end has the same issue as it's pretty standard. BTW You can change the implementation fairly easily, if for example you want to improve the performance. (which is ok, but not great)
quickfixj is generating its classes out of the standard fix dictionaries, so there is no limitation in terms of the framework and from my experience it is very accurate, new releases from 1.5.3 to 1.6 seems to have some issues between 4.x and 5.x compatibility but in general it is quite straight in managing a mix of versions and custom fields, it boils down to the version of reference between the counterparties which applies to every message but essentially on the message level all versions can be woven in / customised
Related
We have a java wicket 1.4 application not so large, but now we need to integrate bootstrap 4 to it. Consulting the apache wicket site, we see a integration come since wicket 6.0 version but it is not supported for older versions.
Having project time considerations, We have two alternatives: First, migrate from 1.4 to 1.5 and then to 6.0, this to support the "native" integration, or second, to include bootstrap in the html head instead of the html generated directly from wicket.
The first one is probably the best option but could imply a great effort. The second one, is not a clean solution but could be a temporal one.
Do you know which implications or potential issues could be arise both alternatives?
I guess you want to use https://github.com/l0rdn1kk0n/wicket-bootstrap because Wicket itself doesn't provide anything special for Bootstrap. The "problem" here is this library does not provide integration with Bootstrap 4 (https://github.com/l0rdn1kk0n/wicket-bootstrap/issues/540) because v4 is "almost ready" for about 3 years now.
I'd suggest you to use the second approach.
Updating to a newer version of Wicket would be good anyway! Ignoring the new features and the bug fixes there are several security fixes which might or might not affect your application.
Use the second approach - add the bootstrap.css to your html head and use bootstrap classes manually in your html. Just use standard Wicket. Some bootstrap components like Slider, Progress Bar, Datepicker and Modal we have implemented as components on our own.
This gives you full control and free's you from external libraries which are not updated in time, not compatible with other frameworks/versions and so on.
We are happy with this approach and avoid this way the problem you have.
in detail:
if we use public API for example, write java program for example , in JDK 1.4, if should run correctly in all version above it. in all update version in 1.4, in 1.5, 1.6 and 1.7?
Also , what is the combability rule between different updater versions , for example 1.6.22 and 1.6.23 what can not be changed, what can be changed?
of course, public API definition can not be changed, how about others? javadoc? internal API definition, implementation?
It will be great if someone can point a concrete official document on this topic. thanks,
there is one example in java document bug, that they intended not to change between updater version. see http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6475885
this should be one of its big picture, but we better to have a complete description on this.
need to know the complete story so that we feel safe to upgrade to bigger version.
The general rule is that any code that is written and compiled against the APIs of Java X should run on Java Y where Y >= X.
There are occasional exceptions to this; e.g. where the application's behaviour depends on some undocumented behaviour (typically a bug) in Java X that was corrected in a later version.
AFAIK, there is no single document that lists these incompatibilities. The release notes for all of the Java major releases include a list of changes that could result in breakage of older code.
Having said that, the prudent approach is make sure that you thoroughly test / retest your software when you upgrade to a more recent Java release. And if your software is shipped to customers / clients, let them know if / when it is safe for them to upgrade, and (if necessary) provide them with fixes for any problems that your testing has uncovered.
need to know the complete story so that we feel safe to upgrade to bigger version.
Feeling safe is beside the point. Thoroughly test your application on the later version. That is the only practical solution. And that would be the case even if each and every incompatibility was exhaustively documented.
Think about it. How can you know for sure that your application won't somehow be affected by change XYZ? Or that some 3rd-party library that you use won't be affected? Answer: you can't.
No manner of complaining here that you think that Oracle should handle this issue differently is going to make any difference. Not that I think that they could handle this better without changing their business model. How much would you be prepared to pay for a Java platform that guaranteed there were no version compatibility issues?
This is not a full answer but I will add that will-it-run and will-it-compile are two different things. Keywords introduced in 1.5 will prevent some 1.4 code from compiling but the byte code will run just fine.
Almost anything can be changed between versions there are no set rules for such things. Use the release notes to publish changes or review them between versions such as:
http://www.oracle.com/technetwork/java/javase/jdk7-relnotes-418459.html
Usually only bug fixes are the cause of minor versions (like you detail 1.6.22 - 1.6.23), or simple enhancements which are only ever good things. When the major version numbers change then you can expect more major changes but you still "hope" for reverse compatibility.
I don't think JDK ever changes an API that breaks backward comparability (except unintentionally).
They introduced #deprecated tag in the very beginning, probably thinking that they may need to do some API cleanup in future. But that never happens. No #deprecated API has ever been removed, or behavior changed.
if we use public API for example, write java program for example , in JDK 1.4, if should run correctly in all version above it. in all update version in 1.4, in 1.5, 1.6 and 1.7?
See this table, that shows breaking changes in public jdk APIs
See these official documents about versions compatibility:
Java SE 7 and JDK 7 Compatibility
Java SE 6 compatibility with J2SE 5.0
Incompatibilities in J2SE 5.0 (since 1.4.2)
Java SE 1.4.2 Compatibility with Previous Releases
I am just learning about android app development and have created my first app which is a relatively simple app with a link to a gallery of images and some text pages. I created this using the 1.5 platform as it seemed sensible to make it backwards compatible. I've been testing it on 3.0 and it comes up tiny on the screen and I have since learnt I need to use supports-screens and other related commands to allow variable screen support which from what i read is only available in 1.6 and above. As a result I need to change the app platform to 1.6 or above and my questions are as follows:
1) Am I able to just go to project properties and change the platform version tickbox to a newer one (in this case 1.6)? As I tried this with the project but the supports-screens tag still gives an error (which it doesn't when I create a brand new project)?
2) What version should I be creating it in these days for ideal backwards compatibility but able to use most desirable features? I understand 1.6 includes a lot of the newer functionality but according to http://developer.android.com/resources/dashboard/platform-versions.html only about 4% of people are using less than 2.1 so is it better to just code using 2.1 (assuming I want to target mobiles and tablets)?
Thanks so much for your help as ever,
Dave
Take a look at this. It explains how you can go about changing your AndroidManifest.xml to specify which version of the SDK to use. You may also need to update default.properties to point the target to the proper api value.
This really depends on what you want to do. If you require something from 2.1 or 3.0, then I think you need to go with that. But if you can get by using just 1.6 and still have all the functionality that you need/want, then I would definitely recommend using 1.6.
Given an application using Spring 2.5, when migrating to Spring 3.0 what are the likely areas that will be pain points, i.e. things that the development team will have to spend time on to get things working. Assume the team would not try to take advantage of new Spring features as part of the upgrade, but just get the application to the state where it works as it did on 2.5. Taking advantage of 3.0 features would be the next steps to consider.
Edit: I have revised the question to focus on the pain points of the upgrade, which is what I'm really after.
Probably the biggest change in Spring 3.0 is that it now requires J2SE 5.0.
One of the Spring developers reply for a compatibility question in this blog entry.
Spring 3.0 aims to be 99% backwards
compatible with Spring 2.5. The core
APIs and SPIs will remain stable in
order to keep existing extensions (and
of course also existing application
code) working. Introducing generics
and varargs, as we've done in M1 and
M2, should still preserve binary
compatibility. That said, we generally
recommend rebuilding your applications
for Spring 3.0, in order to catch
potential API issues early. This will
also allow you to get the maximum
benefit from Spring 3.0's Java 5 API
refinements.
If you're lucky, then nothing will need changing, it should all just work. The Spring guys are very careful to retain backwards compatibility.
The biggest reason I can think of for it not working is if you're using code that was deprecated in 2.5, and marked for removal in 3.0 You can find that list here.
We provide a popular open source Java FTP library called edtFTPj.
We would like to drop support for JRE 1.3 - this would clean up the code base and also allow us to more easily use JRE 1.4 features (without resorting to reflection etc). The JRE 1.3 is over 7 years old now!
Is anyone still using JRE 1.3 out there? Is anyone aware of any surveys that give an idea of what percentage of users are still using 1.3?
Sun allows you to buy support packages for depreciated software such as JRE 1.4. For banks and some other organizations, paying $100,000 per year for support of an outdated product is cheaper than upgrading. I would suggest only offering paid support for JRE 1.3. If anyone needs support for this, they can pay for a hefty support package. You would then shelve your current 1.3 code base, and if a customer with a support contract requires a bug fix, then you could fix the 1.3 version for them, which would likely just mean selectively applying a patch from a more recent version.
Even JDK 1.4 reached the end of its support life in Oct 2008. I think you're safe.
But don't take it from me. The people that you really need to ask are your customers. Maybe putting a survey up on your download page and soliciting feedback will help. If no one asks in three months, drop it.
Why not have your program report back what version of Java it is being run with. This will give you an idea of your user base.
I highly recommend dropping support for Java 1.3, and instead of doing a minor upgrade to Java 1.4, why not use Java 1.6? There have been massive improvements since 1.3. You really are missing out.
End-of-life is normal part of software's life cycle.
The real question you should ask/answer is whether you have a compelling business need to add features to the "old" versions. If not, you can continue to offer it for customers who need it -- but encourage everyone else to take the latest & greatest which requires 1.4 (or 1.5/1.6).
It's difficult to give figures for what companies use internally. There do exist figures for browser plugin installation, but Sun's figures are confidential.
1.3 support stopped some time ago (Solaris 8 vintage support dragged on for a bit). 1.4 has completed its End of Service Life, but is likely to be supported under Java for Business for yonks. IIRC, if you try to download 1.4 from the archives at sun.com then you are asked for some information such as an e-mail address. 1.5 is more than half way through its service life (but its still quite common on Macs).
It's not that difficult to use 1.4 features optionally. You just need to load one class via reflection (or just package it differently) and then have a 1.4 and 1.3 implementation of a light abstraction over the new features.
Why not only do critical patches for 1.3 & 1.4 if anyone actually requests them and do all new releases on 1.5 - the current oldest version supported by Sun?
I was developing with jdk 1.4 for a long time while jdk 6.0 was out. We couldn't upgrade(clients this, servers blablabah). At some point, we just upgraded without talking too much about it. Clients upgraded without being annoying, "this upgrade will fix lots of security holes, many bug fixes, improved performance :-)".
Right now, I try to keep my code compatible with jdk 1.5, I have no concern at all for people running 1.4 and below. At some point, they'll understand that it is in their best interest to "try" upgrading.