Think about how Java is different from its predecessors:
1. multi-platform without any source or object code change.
2. comes with a large number of libraries. You have to write less code
of your own, but the penalty is you include lots of code you don't
use,, which is not filtered out. Jet to some extent can prune out
code you don't use.
3. rigid specification of what a given program will do. Sizes of all
primitives are nailed down. Results of all operators are nailed.
Logical bit representations are nailed down.
4. multi-threaded out the box. No special platform-specific library
needed.
5. easier to find errors at compile time. Strong type checking.
6. easier to find errors at run time. Mandatory bounds checks, null
pointer, initialisation etc.
7. standardised documentation.
-----------------------------------------------------------------------------
Presuming these trends continue, where should Java go next?
1. add design by contract to help find bugs sooner and more formally
specify what a method is expected to do.
2. 2D display of expressions to mimic traditional mathematical
notation.
3. more use of idiomatic syntax like for:each so that you can tell at
a glance if you have common pattern or something weird going on.
4. system for automatic lazy install and update of any libraries or
application code. It is no longer the programmer's problem to manage
manually. Call this Java Web Start Greased.
5. use of SCIDs. See http://mindprod.com/project/scid.html
6. add ability to declare units of measure to primitives. This gives
you dimension checking and automatic unit conversion.
7. standard sup****t for a complex type. x + iy
8. formal bounds declaration on variables and parameters.
9. Style sheet layouts that can layout and label a given set of fields
in a pleasing way given certain about of screen real estate. You
specify the relation****ps between fields logically, not in terms of
rows, column, or positions. Labels disappear or appear as real estate
shrinks or grows. The idea is to get rid of so much fiddly layout
code. You should be able to display and edit aesthetically given just
the information in a SQL database and metadata.
--
Roedy Green Canadian Mind Products
The Java Glossary
http://mindprod.com
Think about how Java is different from its predecessors:
1. multi-platform without any source or object code change.
2. comes with a large number of libraries. You have to write less code
of your own, but the penalty is you include lots of code you don't
use,, which is not filtered out. Jet to some extent can prune out
code you don't use.
3. rigid specification of what a given program will do. Sizes of all
primitives are nailed down. Results of all operators are nailed.
Logical bit representations are nailed down.
4. multi-threaded out the box. No special platform-specific library
needed.
5. easier to find errors at compile time. Strong type checking.
6. easier to find errors at run time. Mandatory bounds checks, null
pointer, initialisation etc.
7. standardised documentation.
-----------------------------------------------------------------------------
Presuming these trends continue, where should Java go next?
1. add design by contract to help find bugs sooner and more formally
specify what a method is expected to do.
2. 2D display of expressions to mimic traditional mathematical
notation.
3. more use of idiomatic syntax like for:each so that you can tell at
a glance if you have common pattern or something weird going on.
4. system for automatic lazy install and update of any libraries or
application code. It is no longer the programmer's problem to manage
manually. Call this Java Web Start Greased.
5. use of SCIDs. See http://mindprod.com/project/scid.html
6. add ability to declare units of measure to primitives. This gives
you dimension checking and automatic unit conversion.
7. standard sup****t for a complex type. x + iy
8. formal bounds declaration on variables and parameters.
9. Style sheet layouts that can layout and label a given set of fields
in a pleasing way given certain about of screen real estate. You
specify the relation****ps between fields logically, not in terms of
rows, column, or positions. Labels disappear or appear as real estate
shrinks or grows. The idea is to get rid of so much fiddly layout
code. You should be able to display and edit aesthetically given just
the information in a SQL database and metadata.
--
Roedy Green Canadian Mind Products
The Java Glossary
http://mindprod.com
Think about how Java is different from its predecessors:
1. multi-platform without any source or object code change.
2. comes with a large number of libraries. You have to write less code
of your own, but the penalty is you include lots of code you don't
use,, which is not filtered out. Jet to some extent can prune out
code you don't use.
3. rigid specification of what a given program will do. Sizes of all
primitives are nailed down. Results of all operators are nailed.
Logical bit representations are nailed down.
4. multi-threaded out the box. No special platform-specific library
needed.
5. easier to find errors at compile time. Strong type checking.
6. easier to find errors at run time. Mandatory bounds checks, null
pointer, initialisation etc.
7. standardised documentation.
-----------------------------------------------------------------------------
Presuming these trends continue, where should Java go next?
1. add design by contract to help find bugs sooner and more formally
specify what a method is expected to do.
2. 2D display of expressions to mimic traditional mathematical
notation.
3. more use of idiomatic syntax like for:each so that you can tell at
a glance if you have common pattern or something weird going on.
4. system for automatic lazy install and update of any libraries or
application code. It is no longer the programmer's problem to manage
manually. Call this Java Web Start Greased.
5. use of SCIDs. See http://mindprod.com/project/scid.html
6. add ability to declare units of measure to primitives. This gives
you dimension checking and automatic unit conversion.
7. standard sup****t for a complex type. x + iy
8. formal bounds declaration on variables and parameters.
9. Style sheet layouts that can layout and label a given set of fields
in a pleasing way given certain about of screen real estate. You
specify the relation****ps between fields logically, not in terms of
rows, column, or positions. Labels disappear or appear as real estate
shrinks or grows. The idea is to get rid of so much fiddly layout
code. You should be able to display and edit aesthetically given just
the information in a SQL database and metadata.
--
Roedy Green Canadian Mind Products
The Java Glossary
http://mindprod.com
Think about how Java is different from its predecessors:
1. multi-platform without any source or object code change.
2. comes with a large number of libraries. You have to write less code
of your own, but the penalty is you include lots of code you don't
use,, which is not filtered out. Jet to some extent can prune out
code you don't use.
3. rigid specification of what a given program will do. Sizes of all
primitives are nailed down. Results of all operators are nailed.
Logical bit representations are nailed down.
4. multi-threaded out the box. No special platform-specific library
needed.
5. easier to find errors at compile time. Strong type checking.
6. easier to find errors at run time. Mandatory bounds checks, null
pointer, initialisation etc.
7. standardised documentation.
-----------------------------------------------------------------------------
Presuming these trends continue, where should Java go next?
1. add design by contract to help find bugs sooner and more formally
specify what a method is expected to do.
2. 2D display of expressions to mimic traditional mathematical
notation.
3. more use of idiomatic syntax like for:each so that you can tell at
a glance if you have common pattern or something weird going on.
4. system for automatic lazy install and update of any libraries or
application code. It is no longer the programmer's problem to manage
manually. Call this Java Web Start Greased.
5. use of SCIDs. See http://mindprod.com/project/scid.html
6. add ability to declare units of measure to primitives. This gives
you dimension checking and automatic unit conversion.
7. standard sup****t for a complex type. x + iy
8. formal bounds declaration on variables and parameters.
9. Style sheet layouts that can layout and label a given set of fields
in a pleasing way given certain about of screen real estate. You
specify the relation****ps between fields logically, not in terms of
rows, column, or positions. Labels disappear or appear as real estate
shrinks or grows. The idea is to get rid of so much fiddly layout
code. You should be able to display and edit aesthetically given just
the information in a SQL database and metadata.
--
Roedy Green Canadian Mind Products
The Java Glossary
http://mindprod.com
