this example is in java.

think of this this.
a language that the primitive data type can remember it's last
value!

what for ? i dont know.
but if language are to model real world data systems
- this is realistic.

e.g you can remember yesterday?! can't you- and in a programming language - you are a data type?

so here's the example:
--------------------------------------------------------------------
import java.util.Stack;
import java.util.Iterator;

public class Variable
{
private class type;
private Stack<Object> values;
private Object currentValue;
private static int max_memory=10;
public variable(final Object value)
{
this();
currentValue = value;
}

public variable(){
values = new Stack();
currentValue = null;
}


public void setValue(Object value)
{
if(currentValue!=null)
{
// push it on the stack
if(values.size()<max_memory)
{
values.push(currentValue);
max_memory++;
}
currentValue = value;
}
else
currentValue = value;

}
public Object getValue(){return currentValue;}

public Object previousValue()
{
if(values.isEmpty())return null;
return values.peek();
}

public Class currentType()
{
if(currentValue==null)return null;
return currentValue.getClass();
}

public Object[] previousValues()
{
if(values.isEmpty())return null;
return values.toArray();
}

public void clearMemory(){
values = new Stack();
}

}

---------------------------------------------------------------------
using the variable class.


Variable var = new variable();//null value
var.setValue(10);
var.setValue(20);
var.setValue(30);
var.getValue()->30;
var.setValue(var.previousValue());
---------------------------
what could such a 'smarter variable' be used for?!
don't know.
but it can-remember?! - all its settings -
--
typical variables have no idea of the last data they held?!

e.g

Type t = new Type;
[where t is say - a boolean,char,etc]
t = new Value ; e.g int x = 10;
x = 20;// oops !! x can't remember its previous value.

print x [prints current value only]
print x.previous-value [no such method exception!!!]

but I am a system not a data type...
And like you asked, of what use is this data type?

^^
ok. let me try to explain.
what is the use you say?
um -- since this feature isnt in current programming languages - it would be
hard to explain it to a user but if it were i guess people would find a use
for it.
e.g old vb didnt have recursion ? so explaing recursion to a vb user would sound
like greek,but a c,c++ , java user would wonder how ever they coped without it?

potential usefulness:
----------------------
debugging purposes. (this implementation will cripple even a very fast machine cuz
its memory and computationally intensive. but that aside - it really mimics
"real life scenerio . think of "flash back" .
current languages would need meta programming to achieve this effect.
if you use c++ , its complex enough,
if you use java ! reflections is messy enough)

imagine this source code:
--------------------------
class B
{

function a()
function b()
function c()
function d()
function e()
etc

}

now when testing the code.
you want to know where you are!
lay programmers use "system.out.println"
when at function a()
println() prints the location as "function a()"
when in function b() println() prints "function b()"
etc.
problem is say there is a client using class B.
say class Bclient.
when class Bclient calls B.a() - the print out is "function a"
when it calls B.b() - the printout is "function b"
when it for debugging sake , the order of functions calls is important,
like, which function did i trace before the current one?! -
then more boiler plate code is written.
more data structures are called up , like stacks and lists,
it begins to get messy.
But sometimes in heavy debugging sessions - order of execution and a datatype
that "can remember" is needed!!
in typical oop languages there's nothing like this.
when a variable holds it's present value , the last value is lost forever!!
it like oop variables suffer terrible amnesia.
But believe me , if this need were addressed many many many uses would crop up for it.
Kinda,like the naira land function thing i posted sometime ago.
this how the philosophy works.
People use what they have. and if they dont know more they're okay with the status quo
this status quo is "reality" to them.
but when the "reality" is augmented by new implementation - they adopt it.

some measure of this implementation:
in functional programming.
in fp, a variable is assigned once.
and it retains it value throughout the life time of the app.
i.e it doesnt suffer amnesia.
say X = 10.
X will always be 10. (except it is "purged"
this makes debugging really easy. the coder never has to wonder what the "previous value of X was"
in oop.
X could assume infinite values!!! .

say.
X=10 (line 1)
y=20 (line 2)

for(;x<200;x++) {x assumes so many values }

x=x/20 (line 30) etc.

have you ever gone thru your source code , reading it over to find what value x was at each particular time?! (then you're in essence doing what a smart varaiable should be doing-crudely)

or have you seen this in code:

using a tracer (e.g system out.println() or a debugger)

x=10; println("x is "+x)
x=20;//print it out .. (you'r tracing the history of all the storage values of x thru out your program.

USING THE SMART VARIABLE ALTERNATIVE.

SINCE A SMART VARIABLE CAN REMEMBER ALL ITS PREVIOUS VALUES UP A CERTAIN POINT..
to get previous value of a variable you query the variable itself!!

now at line 1000. you're using the variable 'x' .
variable printFunction(variable)
print all variables of x from current value back to initial assigned value.
This will do print 20,10 etc.
bye bye println.
bye bye debugger at 1000 lines below sea level!

contingent decision making:
--------------------------
like:
in typical oop languages - you have to keep an extra variable as the "memory variable"
when you need to remember a value after changing it.
e.g
imagine this real life scenario.

student has a bag of sweets and is asked to come speak infront of the class.
students shorts has no pockets so he gives his sweets to his friend to hold for him
after making the speech he returns to his friend to collect his property.
(this is how most variables are)
but if students sweets is less than original quantity (he'll called friend a theif)
else he'll consider friend as honest.
its a bit contrived ,
but you get the point,he's referencing a past value to make decisions with.
in a variable that can remember its previous state, its going to be like the
student's short has pockets. when the student rises to go make the speech,
its as if the value of sweets in hand has been set to zero , cuz he's hidden the sweets,
after the speech,he goes back to retreive past value (by dipping hand in his pocket)
, he makes a contingent decision after retrieving past value (e.g if sweet less by any amount - then he checks if his pocket has a hole)!!
very artificial example , but , in real life contingent decisions based on past data
does have to be made.
and without smart variables , other variables have to be created.
anyway,point is, some variables are just used to mirror states that fold into one
variable eventually.

well, if it confuses you , just shrugg it off. its just a muse expressed.

Do you realize that you can only access variables during application runtime? Because the way you described this feature, it seems to me as if you believe this data type can be accessed outside runtime.
Assuming, this data type is created and used.. Then we are talking of the size of your application increasing exponentially in memory after the execution of every event loop? Yes, you were talking about taking a snapshot of every variable in your application at every state in your program execution.
For debugging purposes, it is not even useful. Stdout still exists..
#include <iostream>
using namespace std;
int main()
{
int x = 5;

for(int i = 0; i < 50; i++){
cout << "these are the values of 'x' in loop " << i << " of execution\n";

cout << "the value of 'x' is " << x++ <<endl;
}

return 0;
}
this is as verbose as it gets... Can your data type beat it?

okay. Let me call this a smart variable. You'll notice its a primitive that is made up of a data structure,and some algorithms. No. I dont intend to give the impression that it will be be used outside the runtime. The debugging example, is just one of the uses i can think of for it. Theyre myriads of others that cud b discovered during usage. It will b very expensive to use to use in todays architecture,if and only if it is not configurable e.g a smart variable cud b configured to operate like todays scalar primitive variables (i.e it doesnt remember previous state) or a variation of that e.g store last x values (x could 1 or 10 or 100) etc so configuration could minimize cost. On the debugging issue, u know software testg and debugging takes more time than the actual programming, so detecting variable state is a real need. But insted of stepping thru code wt a debugger, u could go to run the program and make a particular smart variable printout its histories! While the program is running. Bye bye for loops, bye bye excessive tracing. Anoda point i mentioned is the use of previous state data in real time. With current typical languages i know of, and i dont know enuff, previos data is lost and cannot be recovered after assignation. E.g x=1 (first assgn) x=2 (second assgn . First assgn lost forever!) . To recover previos states, programmer (physically "walks" thru the source code using his eyes). Debugging is just one aspect , anoder could b program recovery and roll backs, for example in the "x" example if the program crashed at an unknown point , the interptreter could asked to run the program but substitute the nth assignment with n-y assignment if it is suspected that the nth assignment was doubtful. Think, of , undo redo at the primitive level . If it exists at the primitve lvl via smart variables it may b easier to create apps with this effect. Add serialization and data compression wt timing and an os can have all applications revert to previos state. Imagine an outage yet ur system desktop can revert back to the state it was 10ms ago. Imagine a stock analyses app where "wha if" analyses are run as stock value changes in real time. Presently databases are used to store data and require a query language but it cud b easier. Fact is primitively smart languages dont compare performance -wise with their imperative counterparts. Lisp,ruby are still slow while c,c++ still ace speed tests.

a primitive made up with data structures and algorithms? That defeats the purpose of a primitive.
I think we are talking about containers now. Your smart variable must have a container back-up. Imagine using a 'list' where you would use an 'int'. Its just wrong.
about saving states of applications, I think you will agree with me that applications only save needed data. Anything more than that is junk.
Example: assuming a needed data is of an 'int' data type. So your smart varaible allocates memory of 40bytes (for 10 previous values) and saves 4bytes of useful data but mine a primitive int creates 4bytes of memory and stores 4bytes of data. i'd say mine is very efficient.
If you want to see a good example of an application that uses states exclusively, goto the Git website and study Git's architecture.
But your smart variable can be useful on 512bit OS though

@lordzouga "a primitive made up of data structures?" . Yes yes yes. That's the only way the required functionality can be acheived. My case is hypothetical like i had explained in previous posts, the justification 4 the endeavour being that this smart varaible would have a feature current varaibles dont have i.e it's not amnesiac (doesnt forget previous state). You're alarmed that a "primitive" cud have inbuilt data structures! I'm not . I use the word primitive in the sense of an object that is a basic building block in a system. E.g cells are the primitives in the human body but a cell is a very complex composition. So yes, i'm fantasing or musing about a language where its basic building block (it's primitives) is smrter than the what we typically have. Current primitives are simple cells that store only a single value and so by design are amnesiac (forgetful). Dont forget that modern languages have some advanced primitives like the string class. Big integers for arbitrary sized numbers. These are composite data types with containers and some intelligence designed to be used at the primitive level. What i'm proposing is only more complex . On the cost issue, i said they could some work arounds, e.g set container size etc. "it is impracticable"! . If u say this, ur reasoning from todays viewpoint. Tomorrow could provide architectures that are 1000 times more advanced ,speed and memory wise. Remember, java garbage collection and vm was once shut down as no no but those features have set the bar for subsequent post-java languages. So assess the idea with a futuristic mindset where memory is more abundant processor faster etc. @fayimora this isnt functional programming nor an advocacy for that paradigm. Functional programming tackles variable amnesia by making variables write-once , data value isnt changed after it is set, in a way the smart variable i'm talking about is assisted by a stack (LIFO), so it has a history and is state reversible a feature not currently available in popular languages. I proposed this because it mimics real life organisms more. As we go thru life we change states but we dnt forget our previous states and we carry the memories of the past with us effortlessly. "facebook/twitter social graph" "run out of memory!" - u didnt read my last post b4 shooting. I prescribed some cost cutting measures that cud b put in place to reduce overhead. Of corse a purpose built virtual machine wud have to b implemented. I'm not going to repeat myself again. Besides face book social graph is more of a static data structure with people adding/removg /querying nodes. I'm thinking more seamless ai applications that need to vre evaluate past data without losing hold of present. Even if memory were not the issue the cost of making simulations using some of the histories of a smart varaible would be very expensive (run in factorial time). "u find it hard to comprehend.../ gather ur thoughts in few words" - the concept is more multidimensional and unconventional. So it cannot be relayed to an askance audience without washing it with a lot of words. Gather my thoughts into in few words ! On forum that caters to spontanaeity. I'm typing on fly mister not writing a newspaper editorial,mister!. If you dont understand me , re-read and digest my proposition b4 rushing off a premature reply. Have u visited other forums or read other peoples essays thyre some long works weaving a point out there.

OP please don't start getting into the illusion that you are up to something big here. These problems are well known and understood in CS especially by the Americans. Immutability could be a way of describing the solution to your problem. To properly understand your problem write up a proper use case of your Variable class in code and share it here. Also you need to understand the fundamental difference between language primitives, Data Types, Data Structures. Your Variable class is no longer a primitive. you are trying to build a data structure which if you do successfully could be a source of revenue to you. And most data structures are built from manipulating array primitives which is not done in your class. I suppose your stack replaces that. You need to study up on Data Structure and Algorithms and move on to consider the algorithmic complexity of your solution.
Also check my favorite language, Clojure on their take on this http://clojure.org/state.
Clojure has also facilitated the writing of the datomic in-memory db system. Which can help you keep snapshots of what has happened in a clean idiomatic way written by a master. Rich Hickey

John

@fallguy, so, the problem here is system architecture not programming language.
You say I am reasoning with the current architecture in mind? But that's what you are doing too (unless you have designed or written specifications for the future architecture) you can't be making your arguments based on a future architecture that doesn't exist.
Besides, I am yet to see a use case where your smart variable trumps usage of current primitives..

why was my post hidden? What did I do wrong?

I think fayimora hid your post because you guys were derailing the thread, but he saw your reply...

@john grow up and stop actng like a sour puss. What's wrong with sharing an idea? Read and digest b4 commentng, i know we all hav shortening attention span but bringing up an issue that had been pain stakingly addressed is bad enuff. " Problem are well known and understood ... ": really? Many ideas are not novel only re-discovered independently . But if as u say it is well understood then papers and articles on this partcular issue shd b rife. Either saying its innefficient/impractical/bunkum/etc or so-so/worth considering. Give citation sir. "immutability could b a way to describing the solution to ur problem": - another premature shot. I never was talking about immutability ONly , of course to have an unbaised history the variable in question wud have to Write-once , once data is recorded it cannot b changed aka immutability, but a smart variable doesnt require an internal stack (data structure) for that. I'm talking about a lot more than immutability. "to understand your problem, write a use case and share it here ": this must b a joke, right. A use case including configurations could take up to 5 classes nd an arbitrary amount of code. I wrote a simple prototype class in the original post and very lenghty follow up posts , if any cant grasp the english then why bother with code? "you need to understand the basic difference btw primitives, data types, data structures " : again ur missing the point and confusing concepts. The only objective item on that list of urs is the data structures and this is only because data structures are objective language-independent mathematical entities every other is arbitray. In some languages arrays are the primitives , in others lists are , in a language like rebol the primitives are even much more complex so to reduce confusion i define a primitive as the basic building block(bbb) u use to build ur program with. In java, c, c++,etc int,char,booleans,strings are bbb's there used to build a program. So a smart variable is a bbb cuz it cud b used to build a program also.it could b the most basic element in a program if need b or mixed with non-smart bbbs. "your trying to build a data structure which if u do cud b a source of revenue": i'm not trying to build a data structure. Why shud i !? Most wat i need is available and i'm not trying to make money. I'm not even trying to implement a so called smart variable. " I need to study up on algorithms and complexity " : i hav and still am open to learng this issue doesnt need advaced algorithm knowledge. Rich hickey and closure : essentially the so called smart variable is a data banking immutable configurable bbbs. So a language with inbuilt database can do what a smart variable can, but the snag is an inbuilt databasr is corruptible cuz any client can access it an change its data but a smart variable cannot have its data changed so it can b more secure . But its not a big issue since db's can b configured. @lordzouga by current architecture (memory especially and processor speed ) a smart variable doesnt make economic sense. Judging it by its economic infeasibilty is evaluating it from todays viewpoint. All things trening tomorrows computers will much much more powerful than what we have today. I'm thinking in terms of say a computer that is 10 - 30x faster /larger memory wise for a basic test run. It could be much much more for signicant apps. I hav an example in mind and may post it later.

@fallguy, I will be waiting for your example. but then, your variable is not necessarily smart. it just saves data. for me, I think it should be called smart if it can decide on its own when to make a backup and when to release memory

^^
the term may not fit since it has very little logic in it, but i was using
it
in the sense of the variable being better than the relatively dumb variables we typically use.
But with configuration,like i said before, its smarts could
be upgraded.
in the original original example,the smart variable cud be preset to a certain size,
in later posts i said it could be made to function like a typical scalar variable
- have no histories.

anyway here's the example:
--------------------------------------------------------------

IT'S A BIT CONTRIVED THOUGH ,

say you own 20 shares of traded stocks on the nigerian stock
exchange. you want to know what shares will give the highest
value to your portfolio as the stock prices fluctuate among other

things.
with the best combination of stocks you can make a buy decision
to swell your portfolio.

the stocks each start the day at a particular price.
for the sake of relevance,lets say you're only interested in
price movements that are within a certain significant range.
lets say +/- N10 of the starting price.


for each significant price movement, your total portfolio value
changes accordingly,
the particular stock creates a trend,
so you want to watch the trend created by the volatile stock on its

own,
and the portfolio value trend on its on,
then, you may want to analyse values between changes.
intra period analysis.
you may will also want to compare stocks to one another during the

day.
Your program polls the NSE website ,extracting data, and analysing the

data.

let the 10 stocks be:
A,B,C,D,E,F,G,... to the tenth alphabet.

and lets say stock A had 15 significant changes during the day
(i.e +/- N10)

stock B had 10 significant changes,
stock C had no change (its a dud)
stock D had 18 significant changes
stock E had 6 etc...

if for each individual change in a stock value i want to
compute my networth as well capture the values of all stocks
at that time, i'll be having a factorial computation on my hands.
ignoring the stocks that didnt have any significant change,
because multiplication by zero will mess up the computation.

now with this factorial computation and snapshots performed,
a picture of the stock market at that day has been captured for
every single significant change event.
the problem however is that it is very large! (a factorial)

so in the example i gave:
A changed 15 significant times,
B changed 10
C no change
D 18 changes
E 6 changes

snapshot of portfolio for all changes will be:

15*10*1(for c)*18*6 (and so on...)

and for each change - the picture of my stocks at those moments are

stored.
also remember for each significant change your portfolio's total value
is recomputed, and stored -
the size of the data structure to capture all the portfolio total

value for all changes will have to a factorial (too large for any

practical purpose)

even a super computer would be brought to its knees with too many

computations of this nature not too talk of the memory requirement
of any computer.
it would just too much.
imagine 200 stock analysis! = 200! ( a very large number)

But if the a smart variable is used to store the values of each
stock data during changes,
then the massive information that would need to be generated
for each stock change can still be generated any time.

say stock A is represented with a smart variable,
at the end of the trading day,
stock A, variable's LIFO stack has 15 objects.
the entire program is i.e the variables are serialized,
taken home, run on anoda virtual machine (java speak here)
the stock A , still has its 15 object values,
stock B,has its 18 object values, etc.
the program run at home doesnt need to poll the NSE website to
download data in real time,
it just runs the serialized program you brought from work.

The factorial problem is still there - excessive output -
but with a smart variable, and an ability to analyse capture
on a stock by stock basis,
all you as the end user needs to do is-
ask the smart variable,representing the stock,
to give all the data in its container.
in the case of stock A,it will produce 15 values,
in the form of LIFO order.
You click on a particular value in the list,
and the portfolio value at that point in time is reproduced
for you.
Further analysis could be done on the captured value in the
smart variables container to rank it in ascending or descending
order, but the time value would be lost - since with LIFO ordering
a sense of time is preserved without using time stamps.
you know the last input is the latest input etc.

in an app like this , even if a smart variable isnt explicitly
created, the variable to hold the data would still mimic
a smart variable concept.
e.g
A sequence data structure would be created.(list , vector,stack)
stored in a stock class object.
configured to reject insignificant values (not +/- N10)
etc.
methods to get previous data from the object (histories query)
etc.
which is the point i was trying to score about a smart variable,
a variable that has histories!
you can also see that though the stock data at any point in time
is a double , the stock data cannot be sufficiently represented
as a scalar type. with the primitives that come with
typical languages - .
a stock data changes over time, yet it is still the same entity
and the stock data for a particular stock generates histories
(backreferencing) so why not represent it with a smart variable!

with no explicit smart variable object in a programming language
, programmers are doomed to creating them as one-of data types.



what of the portfolio changes!
again this can be captured in a smart variable!! but
not in this century!!- because it is has factorial size!.
the walk around this is to use an external database with
TERABYTES OF STORAGE SPACE, TONNES OF TIME STAMPS, A QUERY LANGUAGE,
ETC.
but this is where it gets beautiful,
if a smart variable could capture the portfolio summary for each

change,
and that smart variable were serialized,
a client application can now ask the smart variable for its contents,
in the case of the portfolio smart variable,
each cell in its stack will be a table ( containing stock names, stock

quantity, stock price (at time of capture), etc)
a client retrieving the content of this
portfolio smart variable can now
re-rank them in say highest to list,
extract the say 100,1000 highest sets (but time information will be

lost because it wont be strictly LIFO AFTEr this)
and rank the best performing stocks against their value at the

begining of a particular time period say at the beginnning of the day,
week,month)

after this analysis, of the highest sets in the portfolio smart

variable's stack, over time , a trend may be identified e.g
some stocks always make it into the highest set,
a month of this or a 3 or 6 months of this and the portfolio
owner may have concrete evidence to make buy sell decision with.

BUT LIKE I SAID,its expensive.
the walk around would be to use - a huge database,
for the portfolio analysis and data storage - but t his is where it
gets messy.
when the stock analyst/portfolio owner is going home at the end of
the day, assuming all the stock watching occurred on anoda system
and the program isnt run online,
he'd have to replicated the database , and learn a query language,
to do everything that could have been done in one place
if the program had an in-memory database by virtue of its smart

variables containers.

secondly,like i said earlier,
even if the user doesnt explicitly use a smart variable l ike i

proposed to hold the stock data,
if he's to keep the contents in memory, he'll inevitable re-create
a smart variable,
but with a smart variable,
the roll back thing i talked about can be very easy to do.
without it, say the user uses a traditional database,
the code to do the rollback can be very messy.

if the user creates a custom data structure, he may not even remember
to implement features for roll back.
but with a smart variable, to get previous data,
all that's needed is a functioncall. because a smart variable is
custom built to make recalling past value possible.

hope i've been able to make some sense instead of ramble-
like i said, a use may appear more apparent after it is implemented.