preliminary report algebraic language december perlis
extraction roots digital computers december
techniques department matrix program schemes december
engineering programming terminology november
square root approximations november
computers procedures november
engineering programming terminology october
equivalence transformation program schemes october
proposal october
engineering programming terminology september
problem programming communication changing machines proposed solution part september strong
error estimation runge kutta procedures september call
engineering programming terminology august
problem programming communication changing machines proposed solution part august strong
recursive curve fitting technique august
modification newton method august
programming arithmetic operations august
simple automatic coding systems july
engineering programming terminology june
convergence iterative processes technique discussed applied iterative procedure solution equation rate convergence iteration convergence iteration june
algebraic formulation flow diagrams june
applications department automatic implementation logic morris
binary function operations decimal command
improved decimal redundancy check
general purpose programming systems
subroutine method calculating bemer
note empirical bounds generating bessel functions
request methods programs april
april
analyzing logical statements produce function table
ibm code
variable width tables binary search facility
programmed binary ibm type january
tables automatic computation january
machine method square root computation january bemer
queue network ibm december johnson
impact developments december
proposed interpretation algol december
method simultaneous nonlinear equations procedure simultaneous solution necessarily linear equations generalization method single function variable december
choice decimal binary representation binary number advantages decimal representation high performance general purpose greater simplicity binary arithmetic unit greater binary numbers directly arithmetic speed obvious important binary addressing instruction increase performance binary addresses essential powerful operations practical decimal instruction hand decimal numbers essential communicating man applications requiring processing large volume decimal input output data time decimal binary conversion needed binary significant decimal time fast binary addition significance decimal binary addressing binary decimal data arithmetic efficient conversion instructions december
research december
method computation square roots division november
technique handling macro instructions november
algebraic translation limited november knuth
flow flow november
multiprogramming feasibility considerations increased parallelism computers noted parallelism presents number problems machine design programming systems minimum requirements successful concurrent execution independent problem programs discussed requirements balanced combination built programmed logic techniques place programmed logic programs supervisory program compiler problem programs november
computers november
shift register code indexing applications communication shift register code fixed order high degree redundancy single error code minimum distance code bit code words employed identification code shift register code period permits code employed simply received zeros shift register time code combination error combinations low probability called communication describes properties application code detail finding employed built drum statistical united technical aid administration october
scientific business applications curve plotter october
statistical programs ibm part ii october
construction flowcharts october
efficient method generating distributed points surface dimensional corrigendum october
recommendations share algol committee october
simple algebraic language october clark smith
algebraic translator october
proposed standard flow symbols october
center october
small size general purpose digital magnetic elements paper examines questions development construction general purpose digital magnetic long memory elements developed laboratory modeling october
survey progress development automatic data processing business management control systems government december iii september
vector transformation linear constraints september
ibm tape matrix compiler september
multi dimensional squares polynomial curve fitting september
diagrams binary applicability design logic paper back binary years diagrams years derived applicability binary diagrams electronic digital design logic september
remarks algol symbol manipulation september
algol committee report extensions september dijkstra perlis
proposal generalized card code characters september bemer
central computers september
role university computers data processing related fields study made university programs united states fields computers data processing operations research related fields university policies organization administration students curricula equipment investigated integrated university program recommended present activities related computers develop university details recommended graduate school sciences september
statistical programs ibm part collection descriptions statistical programs university computing ibm august
construction set test matrices paper equations properties set test matrices determination accuracy routines finding inverse determinant eigenvalues matrix august
proposal feasible programming paper designing programming facility involving digital program assist preparation large scale real time programs facility capable programs variety machines characteristics similar facility basic assumptions random access storage avoid constructed program assumption intended provide aspects program construction programming source program statements errors construct object program characteristics program interrupt scheme large set characters addressing august
educational program computing august
real time data july
high speed sorting procedure july
parameter estimation simple nonlinear models july
binary conversion fixed decimal precision decimal july
construction july graham
remarks practical solution characteristic problems paper concerned practical solution characteristic problem ordinary differential equation sequential computers digital solve initial problems boundary problems mathematical process found machine machine normal activity numerical number papers applied devices problems purpose note mathematical framework model practical procedures assist extension ideas problems june
programming machine extended address mechanism june
technique computing critical flexible automatic june schwartz
high speed june
handling internal symbols language processors substitution oriented symbols programmer oriented symbols language processors examined feasible method presented june williams
computation union june iii
survey progress development automatic data processing business management control systems government december ii part
error analysis floating point arithmetic iii
survey progress development automatic data processing business management control systems government december april general united states united states
note method generating points dimensional april
efficient method generating distributed points surface dimensional april
routine find solution simultaneous linear equations polynomial coefficients april
binary arithmetic variable word length serial april
mathematical procedure machine division april
intelligence programming systems variation exists degree programming systems devices limited human decision procedures attempt made systematic classification devices decision making functions human operators demonstrated feasible date highly desirable future bemer
formulas oriented language technique shown simple algebraic formulas address code
iterative method fitting curve iterative method finding curve squares fit set dimensional points
elimination special functions differential equations set ordinary differential equations mathematical functions requiring subroutines numerical solution electronic tabular data numerical solution hand calculation function generators methods applied equivalent set equations functions practical functions satisfy sufficiently simple differential equations functions eliminated procedure inverse exponential transcendental functions
computing integrals relative merit cost ways evaluating typical integrals bessel functions investigated methods machine evaluation finite series integration differential equation electronic ibm results generally applicable equations wave equation
signal research development automatic programming digital computers jr
arithmetic translator compiler ibm fortran automatic coding
modifications algebraic language
recursive compilers list types memories iii
codes january
comparison programming methods december
console operator examination electronic computers sophisticated programs process complex computing experience operators increasing time selection training operators difficult accurate uniform operator test training aid authors developed console operator examination outlined examination programmed specifically ibm model ii tape record similar programs developed computers december
digital simulation discrete flow systems discrete flow systems discussed characterized items digital systems techniques common approaches physical problems principal portion paper discussion simulation studies illustrate programming problems involved extensive package handling objective optimization parameters storage processing rates traffic flow control procedures simulated compare effects alternative control decisions december moore
methods word inversion ibm december price
method lists important property scheme storage lists data multiple occurrences stored place lists problem subsequent list longer needed desired parts overlap lists lisp employs solution problem present paper describes general method enables efficient method employs reference counts describe extent december collins
multiple precision arithmetic december
programmed error correction project december
note approximating december
searching december
programming numerical solution polynomial equations numerical techniques presented computing roots polynomial equations recommended inversion rules basic newton iterative techniques applied great reliability high degree accuracy rapid convergence realized numerical examples shown illustrate show application recommended procedures december
numerical solution polynomial equation december
survey coded character representation december bemer
survey punched card codes december smith williams
structure december
recent device survey literature history mathematics calculation reference device purpose communication members light evolution present status november
estimation relative efficiency internal sorting methods november
character scanning ibm november
note computation november
simple technique coding differential equations november
computation control november
squares fitting great points november
compilation computers neliac neliac compiler based algol developed laboratory compiler univac compiler generate version running program generated machine code control data corporation cdc neliac essentially identical input language november jr
assignment problem assignment problem formulated briefly discussed efficient solution presented algol code empirical relation solution time size problem based extensive experiments carried digital november
polynomial november
squares fit orthogonal polynomials november
assignment november
iii november
ii november
real zeros arbitrary function november
solution linear equations november
sort november
bessel functions kind november
bessel function set integer orders november
digital computers universities iv october
note calculation interest october
evaluating numbers expressed strings english words october
character set proposals october
coefficients october
october
parallel processing october
comments technique counting october
list systems programs ibm univac october romberg
numbers digital present communications systems single characters groups coded simple terminal english words form sparse set combinations present methods systems terminals numeric representations entire words common character character representations requires approximately present transmission time costs code language translation schemes made transmission numeric binary single character transmission dictionary words names people october bemer
automatic programming classes october
computers engineering instruction april committee engineering university committee project computers engineering education special discuss topics pertinent project report key ideas offered selected topics october
report university computing center october
digital computers universities iii september
decision rule improved efficiency solving linear programming problems simplex september
rational interpolation continued september floyd
september iii
september
comments fortran user september
expressions evaluating september
memory september
problem symbol manipulation student september
digital computers universities ii august
ii august thacher jr
august thacher jr
ii august thacher jr
words corrigendum august
technique counting august
counting ibm august
short study notation efficiency august smith jr
neliac algol august
programming compatibility family related digital computers july
combining algol statement analysis checking july
scheduling parts scheduling external constraints july
terminology project july
character set proposals july
digital computers universities part july
complex exponential integral july
concept large design june
interval estimation time state total time ratio process june
solution simultaneous ordinary differential equations general purpose digital june
symbol manipulation threaded lists corrigendum june perlis
solution polynomial equation method communications acm june thacher jr
june thacher jr
evaluation legendre polynomial recursion june galler
evaluation polynomial recursion june galler
evaluation polynomial recursion june galler
evaluation chebyshev polynomial recursion june galler
conversion floating point representations june
short method measuring error squares power series june
scheduling parts introduction theory order fully fast simultaneous processing large extent schedule workload scheduling routine capable extremely rapid execution prove construction schedule determining programs run respect scheduling minimize time executing entire workload subset subject external constraints precedence applicable wide class machines june
defining algol assignment statements june floyd
compiling june
department mathematics state university june
future automatic digital computers june
words
technique counting binary
start automatic storage assignment
computation square roots continued
code
report algorithmic language algol naur
number april knuth
high speed multiplication process digital computers april
april
bessel function asymptotic expansion april
bessel series expansion april
control logical block diagnosis data loading paper describes section integrated diagnostic monitor checking sections instructions subroutines object program method diagnostic operations format similar program makes convenient simple paper describes number diagnostic features included april
combinations integers time april brown
proving theorems pattern recognition april
macro instruction extensions compiler languages compilers constructed small set functions made extremely powerful conditional assembly nested definitions notation serve make compiler capable general extensions language april
symbol manipulation april
syntactic semantic algol april smith
introduction information processing language april
symbol manipulation threaded lists april perlis
recursive functions symbolic expressions computation machine part april
share standard flow symbols
routine
numerical inversion transforms
defining algol assignment statements floyd
execute operations fourth mode instruction sequencing
note number conversion
technology
preparation
problems
method computation square roots division
basic side tape
coding coding external symbols symbols internal compute carried relevant properties form easily case point presented
programming
sequential formula translation syntax algorithmic language algol sequence states element called controlled state symbol pairs represented transition matrix description syntax time extremely simple rule machine programs statements algorithmic language sequential treatment feasible case optimizing processes recursive address calculation
handling macro instructions corrigendum
solution polynomial equation method
terminology proposal
proposal character code compatibility bemer
proposal set standards acm
high speed sorting procedure january
additional codes january
assembly program ibm january
january
article records research technology science made author union automatic control december
production december
simulation analysis systems december
boolean functions information retrieval systems december
processing magnetic tape files variable blocks december graham
machine calculation probability distribution method presented calculation machine probability distribution references memory minimum multiplication 2n 2n references memory required straightforward method number entries probability distribution method directly applicable distribution exists computed case time accuracy december
geometric weighted check digit verification note describes method geometric checking digits multiplication division addition attempt made show limitations december
dimensional codes detecting multiple errors paper family codes detecting multiple errors binary coded message message multidimensional rectangular array processes encoding error detection based dimensions array effectiveness codes increased introducing check bit essentially check bits dimensional codes discussed paper main family codes restricted dimensions discussion similar multidimensional single bit selection purpose dimensional code detecting errors developed extension higher dimensional codes greater correction power straightforward december
incomplete elliptic integrals december
set legendre polynomials kind december herndon
squares fit orthogonal polynomials december
incomplete elliptic integrals december
mathematical programming discussion discussion mathematical programming special interest committee mathematical programming acm discussion september national acm note consists necessarily represent position discussion december smith
specification languages mechanical languages processors december
engineering application logic structure tables november
design paper presents digital program rapid calculation data essential design utilized computers control systems generated angle required main type november
programming duplex paper describes method duplex programming computers method special programs basic data processing program package duplex operation greater reliability required level integration computers similar processing inputs cross check intermediate final results november
program ray minimum cover abstract complex november
people users groups expressed interest defining language algol language compilers small size computers preliminary report acm national proposals final version recommendations standard subset algol small computers presented november knuth
november
set test matrices november
november
composition generator november
permutation november
interpolation november
tape november moore
map november moore
library loading routine selection november moore
generalized polyphase merge november
low level language subroutines fortran paper describes subroutines coded symbolic languages fortran coded programs deal special arithmetic multi precision arithmetic symbol manipulation bit manipulation character set input output display november
fitting method squares november
proposals improving efficiency algol november
stochastic evaluation static storage allocation october
core allocation based probability october
techniques storage allocation algorithms october jr
semi automatic storage allocation loading time october
storage allocation scheme algol storage allocation scheme machine instruction core store magnetic drum drum storing program blocks data directed programmer auxiliary information algol program routines storage run time full detailed october naur
experience automatic storage allocation october collins jr
dynamic storage allocation including automatic backing store october
dynamic storage allocation information retrieval october
program organization record dynamic storage allocation material presented paper part design core allocation portion ascii programming project ascii concerned application techniques activities intelligence operations october
problems storage allocation multiprocessor multiprogrammed october
general formulation storage allocation general storage allocation process essentially identical respect primary storage total storage set internal external direct address set introduced program sequence relative specific execution time period mapping effective data direct address set storage allocation considered process arbitrary program sequence program linking set existence proof terms completely interpretive program special cases discussed restrictions programs considered practical allocation processes october jr
case dynamic storage allocation october
approach storage compiler october
recent approximate natural considered describing note produce family fast high precision practical exponential evaluation formulas derived formulation october
optimum tape writing procedures magnetic tape read check writing error occurs writing record programmed error routine area tape record area paper procedures basis expected loss time decision rule selecting optimum procedure rule depends number times tape written future case optimum procedure area decision size area formula developed determine optimum area procedure september
inversion complex matrix september
manipulation algebraic expressions manipulating expressions form sum developed conjunction development programs systems analysis problems derive transfer functions block diagrams linear continuous multi loop feedback machine representation derived expression form task compiling developed purpose connection analysis studies application mathematical device original problem september
solution tridiagonal matrices september
iterative method inversion power series september
generalized important event technique september
algol september taylor
critical path scheduling september
chain september
programs september
information retrieval language legal studies september
applied mathematics laboratory taylor model september
number august knuth
rational approximations error function similar functions august
note multiple precision arithmetic august
note fitting great squares august
bit pseudo random number generator bit pseudo random number generator suitable computers tested statistically determine monte carlo programs frequency tests distributions low order runs runs applied half generated numbers interval sets integers obtained bits generated numbers tests numbers set integers significant bits august
generalized polyphase merge august
cobol sample problem simplified control problem chosen cobol users potential users computing systems department store language programming cobol language runs august
set test matrices august
august
basic terminology connected mechanical languages processors suggestions paper part terminology work university research education work national science scientific research august
roots complex number july jr
july
july
find july hoare
quicksort july hoare
partition july hoare
set legendre polynomials kind july herndon
procedures range arithmetic july
note approximating july
iterative method inversion power series july
method integer conversion july
solution tridiagonal matrices july
equivalence declarations july galler graham
approximation curves line segments dynamic programming june bellman
vehicle stability active june
class iteration formulas class iteration formulas rational approximations euler formula derived error estimates iterative procedures derivation euler formula error estimate notation error estimate suggests final section considers euler polynomial shows number formulas derived approach short discussion formula june
logic structure tables logic tables developing logic required procedures operations systems circuits set rules writing logic tables explained means simple examples logic structure machine logic tables logic tables dimensional nature fully sequential parallel aspects logic compiled directly program eliminate flow hand coding june
algol algol report encountered describe complex language difficult learn serve purpose language experience shown report explained fact easy learn algol write algorithms language general powerful handle class problems learn parts algol present compiler languages write assignment statements restrictions compiling languages finally algol things written problem algol general restrictions technical details learn correctly paper features language considered usefulness discussed remarks based authors interpretations algol report june knuth
operational compatibility systems conventions general standards committee share organization considerable effort problem operating efficiently view number programming systems programming systems coded fixed set hardware components fact storage medium required required set conventions considered minimize set time sufficiently interest users george june
state digital technology june
romberg integration june
numerical solution polynomial equation
zeros real polynomial resultant procedure
matrix inversion
automatic indexing survey recommendations preparation automatic read documents contents machines analysis report presents concept automatic analysis relative frequency approach measuring significance words word groups sentences relative frequency approach discussed detail application problems automatic indexing automatic included report summary automatic analysis studies published date writing conclusions point sophisticated mathematical linguistic techniques solution problems automatic analysis
method evaluating area normal function
successive approximations storage problems ordinary differential equations bellman
chaining method addressing secondary keys methods random access files basis key briefly widely chaining method based pseudo random key transformation reviewed detail efficient generalization chaining method permits recovery additional keys presented johnson
design improved transmission data processing code bemer smith jr williams jr
division square root number april
numerical experiments newton method nonlinear problems generalization newton method nonlinear equation form nonlinear elliptic equation solved numerically comparison results results obtained iteration procedure show cases method substantial advantages time accuracy april bellman
practical technique determination optimum relaxation factor successive relaxation method april
survey punched card codes april
ii april thacher jr
real exponential integral april thacher jr
legendre polynomial april herndon
polynomial april herndon
solution polynomial equation april herndon
frequently errors algol programs april herndon
function april herndon
complete elliptic integral kind april herndon
complete elliptic integral kind april herndon
gamma function range april herndon
roots complex number april herndon
set test matrices april herndon
inverse matrix element april herndon
inverse finite segment matrix april herndon
function april herndon
logarithm complex number april herndon
legendre functions kind real arguments april herndon
exponential complex number april herndon
interest april
bessel functions computed april
ii april thacher jr
april
evaluation determinant april
programmed error correction decimal april
table techniques april
approximating transcendental numbers continued april
compilation variables april
bessel functions integral order complex argument april gray
eigenvalues symmetric matrix april smith
topological ordering list elements network network directed line segments free circular elements assumed lines identified terminal nodes nodes assumed topological list lines numeric order simple technique create high speed list topological order april
real zeros arbitrary function
thacher jr
routine
remarks algorithms algorithms
critical path scheduling
correlation coefficients matrix multiplication
generalized technique symbol manipulation numerical calculation
operations
comparison iterative methods calculation roots iterative methods calculation roots including proposed author compared ways theoretical convergence estimates estimates machine running time compare running time methods variety input data
form
statistical programs university
finding minimum network
gamma function
factorial
jr
gamma function
solution polynomial equations method
real exponential integral
complex exponential integral thacher jr
smith
comment paper parallel processing
subroutines symbol manipulation algebraic compiler iii
multiple programming data processing
multiple precision division
program debugging automatic debugging substantially reduce lead time coding effective complex program analysis debugging criteria resulting accurate programs programmer program memory areas set input data maximum loops information set data executive debugging program runs program performing checking functions trace record analysis location errors applications flexible conjunction debugging techniques july es
card format reference files information processing paper card format suitable variety reference files information processing column ibm card divided fields reference material field identification field format reference material flexible format identification reference material includes index source class summary cross reference entry identification includes codes matrix entry number kind major interest source reference identification choice identify material general files card format sufficient identify material reference files programming terms hardware terms equipment machine systems suitable standard card reference files information processing
january
compiling techniques boolean expressions conditional statements algol january
comments implementation recursive procedures blocks algol january
allocation storage arrays algol january
dynamic declarations january
compiling procedure statements comments procedure declarations january
syntax directed compiler algol january
coding efficient arithmetic operations existing formula translation schemes yield coding method reduces number store operations constant subexpressions compilation equivalent subexpressions january floyd
threaded lists constructing combined algol machine assembly processor january evans jr perlis van
scientific compiler displayed formula language january
internal organization translator january galler graham
environment compiler flexible large scale programming facilitate solution information processing problems provide programs programmers developed realized ibm based master file concept storing retrieving descriptions large complex data sets algorithms defined data sets data algorithms expressed family command descriptive languages concept distinct data descriptions content descriptions discussed detail january jr collins jr
translator january clark
magnetic tape data storage algol translator january
recursive processes algol translation january gray
basic compiler arithmetic expressions january
ibm data processing features units ibm data processing recently business machines corporation features disk storage drive disk developed units december
digital computers december
multiple method point boundary problems december
legal implications paper points variety ways systems business industry involved legal suggests call minimizing planning stage techniques suggested making legal effective technology legal generally potential technical aspects systems involved legal situations december
random december
square december thacher jr
december
position point relative polygon december
combination december
matrix inversion december
gamma function december
complete elliptic integral december
term square december
december
multiple integration december mckeeman
adaptive integration simpson rule december mckeeman
december jr
december jr
triangular regression december
fixed world length arrays variable word length computers december
character manipulation fortran ii december jr
decision matrix basis simple data input routine great deal time effort development compiler languages executive systems implementation methods procedures occurs process concerned problem maintaining improving incorporating ideas existing systems area author method employing decision matrix presented handling standard systems programming problem providing data input routine december
evaluation polynomials december knuth
compiling matrix operations december galler perlis
mechanical time motion study mechanical linguistic december
line digital measurement control november
record linkage special difficulties encountered reliable systems searching updating large files documents identified primarily basis names underlying problem making maximum items information considerable power rules applied generally retrieval systems developed study linkage records family research purposes rules ways information utilization matching discussed november
topological sorting large networks topological sorting procedure required problems involving analysis networks problem pert present paper presents general method obtaining topological order permits treatment larger networks handled present procedures greater efficiency procedure machine discussed terms pert network activities ordered machine time method developed procedures needed programmed present implement regard techniques present completely program current november
iteration november mckeeman
complex number real power december jr
evaluation jacobi symbol november
combination november
simpson integration november
certification calculation november williams
path matrix november
matrix inversion november
solution equation november
statement ii november
statement november
group november
iteration november mckeeman
series november
random november
mechanical integrals type integrals november
coefficient determination november smith
november
november
coding case history data analysis october
pattern recognition techniques diagnosis programmed digital computers general pattern classification recognition devices phase current interest artificial intelligence important class present good deal people purpose pattern recognition comparisons machine human performance obtained practical result additional make class approach problem presented multiple adaptive present report background application method october
ambiguity phrase structure languages october floyd
syntactic analysis digital paper account language describe syntax subroutine enables perform syntactic analysis input subroutine consists string analyzed description syntax syntax expressed language output consists trace table results syntactic analysis tabular form subroutine programs years present account language subroutine summary material previously reports additional discussion work relation general questions problem oriented languages string transformations october
october
general order arithmetic october george
permutation generator october
incomplete elliptic integrals october
critical path scheduling october
summation fourier series october
october
gauss method october counts
october
input data organization fortran october
test matrix inversion procedures october
remarks sampling tape file ii october
remarks sampling tape file october
implementing stack october
pass polyphase merge paper presents manner strings polyphase merge number strings levels polyphase merge technique level polyphase merge shown proved october
calculation elliptic functions corrigendum september
day computing september
list processor september
phrase structure grammar algol algol defined formal mechanisms phrase structure grammar stated restrictions shown formal mechanisms type sufficient define algol september floyd
function september
real error function september
tridiagonal matrix september
september
heuristic page multiprogrammed september
current status june september
programmed methods graphical output september
multiprogramming design low cost digital september
analysis file addressing method paper presents file addressing method based calculation address identification record large type files probability distribution records calculated address number required address record computed basis markov chain model mathematics introduction summary sufficient august jr
property classification method file design processing august
finite compact process matrices arbitrary integral domains august jr
procedure large symmetric matrices squares method simultaneous parameters coefficients normal equations elements symmetric positive definite matrix order solve normal equations evaluate precision measures resulting parameters inversion matrix coefficients required procedures matrix inversion advantage programmed high speed elements stored independent order memory capacity handle larger matrix procedure symmetric matrix august
set matrices testing programs august
remarks line segment curve fitting dynamic programming recent paper bellman dynamic programming determine solution problem previously considered problem determination points interval line segments give squares fit function interval bellman primarily analytical derivation briefly solution equation derived point reduced discrete search paper computational procedure considered fully equations shown equation involving minimization found addition shown bellman method applied curve fitting problem additional constraints added line segments curve august
square august
permutation generator august
august
jacobi august
simpson integration august george
rational roots polynomials integer coefficients august
factors august
composition generator august
permutation august
partition quicksort find august
matrix inversion august george
matrix inversion august
function august thacher jr
set test matrices august
august thacher jr
august
coefficients august george
rational interpolation continued august thacher jr
matrix inversion ii august george
evaluation pert network august
square order august
square order august
complex division august smith
august
generation partitions constraints august
august floyd
position point relative polygon august
technique handling analysis variance august
character manipulation fortran august
description list concepts concept defined class objects members processing properties property defined partition set objects classes formal definition concept recursive nature concept list structure correspondence established recursive definition concept description list structure definition description list structure concept built elementary list structures recursive process list structures obtained compared description list structure discussed author previous august
fortran business data processing july
regression coded patterns data editing july
method treatment planning july
matching electronic methods record linkage updating files accomplished number number number social security number records unique number generally individual purposes services received department order determine reports individual identification compared operation subject errors problems maintenance case register reports records linked order provide counts records history earlier paper describes general procedures register maintenance digital present detail initial procedures matching process order comments suggestions experience matching july jr
computation rational approximations continuous functions july
digital synthesis note method generating covariance function digital methods technique testing performance data processing engineering systems inputs form required technique simple produces sense approximately covariance function interval method consists approximating spectral density periodic process spectral lines periodic random order simplify discussion statistical properties generated technique presented terms exact harmonic analysis practice discrete harmonic analysis presented section july
calculation elliptic functions july
triangular pattern hill method solving transcendental equation july
nonlinear regression solution simultaneous equations set bound relation parameters a1 equation a1 frequently problem determining set values minimizes sum squares differences observed calculated values solution equation a1 function nonlinear version gaussian regression iteration scheme minimizing set values shown minimization technique solution simultaneous necessarily linear equations july
machine program theorem proving program proof procedure discussed connection runs improvements july
mechanical integrals type july
definite exponential integrals july
definite exponential integrals july
simpson integration july
factors july
interpolation july
function july
inverse matrix element july george
logarithm complex number july johnson
gamma function july johnson
calculation interactions july
mechanical integrals type july
definite exponential integrals july
definite exponential integrals july
gauss method july counts
complex number real power july johnson
newton july
reduction jacobi july
translation boolean expressions july
simulation timing device july
modified inversion procedure product form inverse linear programming codes paper describes selection row matrix inversion product form inverse developed linear programming codes valuable inversion matrix procedures paper tested operation research engineering ibm substantial cost savings realized procedure july
solution problems approximately eigenvectors july
communication independently blocks july
analytic differentiation june
june
sorting procedures june
june
june
matrix inversion june
logarithm complex number june
exponential complex number june
coefficients june
simpson rule june
permutation order june
item chain linked list june
item chain linked list june
evaluation jacobi symbol june
evaluation definite complex line integrals june
shortest path june floyd
june floyd
generation partitions part count form june
combination june
general order arithmetic june
note sampling tape file june
bit june
redundancy check algol programs june thacher jr
report algorithmic language fortran ii june
initial experience operating multiprogramming research center forms program operation modified univac scientific model years initial searching input output automatic time sharing independently coded problems important machine program modifications evolution additional modifications required added facilitate ease coding operation modifications basic data reduction work load computing center schedule valuable made suggested pointed future improvements basic principles multiprogramming material description evolution programming hardware developed present multiprogramming research center
simultaneous equations matrix inversion routine
romberg integration
chebyshev curve fit
evaluation cosine integral
evaluation integral
evaluation asymptotic expression cosine integrals
cobol problems
introduction machine independent data division
advanced input output cobol compiler
teaching cobol teaching cobol divided main subject areas syntax cobol syntax solving problem programming concepts generally knowledge hardware logic programmer teaching problem determining student hardware logic write cobol programs data students programming difficult measure approach solving problem
floating point arithmetic cobol paper basic operations floating point arithmetic examined cobol procedures specification working storage paper procedures
modular data processing systems written cobol
cobol key object program efficiency question cobol compiler generation efficient object program purpose article present answer creation full utilization constructed cobol library
report cobol
cobol
report cobol evaluation program smith
cobol compatibility
basic elements cobol
cobol
simulation traffic simulating traffic flow national standards data processing techniques make motion pictures vehicle model vehicle assigned digital identification points entry type vehicle desired speed actual speed simulating field data model made determine ability real expected future april
method ambiguity due signal digital design april
calculation april knuth
permutation april
permutation april brown
april brown
permutation generator april
april
jacobi april evans
simpson integration april
addressing multidimensional arrays method representing function variables function values selected points dimensional space picture elements dimensional array exist conventional storage linear array vector means performing transformation set array element space location address element storage vector subject paper noted index address transformation computationally identical conversion number fixed mixed radix number ways implementing transformation april
information algebra phase report language structure group development committee report represents results phase work language structure group goal work proper structure machine independent problem defining language systems level data processing report based part mathematical model called information algebra developed primarily report read interest programming language designers developing theoretical approach data processing interest understanding professional programmers systems authors report present philosophy professional people concerned providing working language systems ideas report similar lines questions comments members language structure group development corporation division univac division ibm corporation management national register george general ibm corporation april
forms part control completely automatic human work speed control perform calculations data processing fast results required action control working real time
computers key total systems control man man machine processes characterized main types type shown
retrieval names record paper discusses limited problem recognition retrieval names large program developed stored program core drum memory solid state records successfully significant original entry time retrieval time procedure involves automatic technique names form names numbers presented final manual program successfully names number usual
romberg integration thacher jr
optimal classification objects
sequence
sequence
gamma function real argument
method representation storage retrieval random codes digit number random codes digit number
list structures
floating point number representation algorithmic languages
binary decimal conversion scheme
evaluation requirements pair requirements easy read easy write compatible paper added automatically translation process programmer economy expression management full valid cobol version printed give advantages compatibility
automatic programming language translation analysis
diagnosis aid algol
simulation analysis systems iii analysis pattern recognition
manipulation trees information retrieval
note boolean matrices
tape iterative program
neliac generated compiler neliac systems machines generated original neliac developed laboratory basic process generate systems neliac language generated existing neliac compiler experience shown inherent difficulty building compilers compilers pointed advantages constructing programming systems report presents results project neliac generate compiler ibm compiler runs produces programs neliac language generated neliac reduction programming time improvement documentation significant
cobol control
difference expression coefficients
rational roots polynomials integer coefficients
interpolation differentiation integration
introduction algol
simulation analysis systems ii solution differential equations january
string language symbol manipulation based algol artificial programming language proposed describing manipulation strings characters symbols concept strings introduced algol report extended strings string arrays explicit lengths ability shift strings symbols comparing boolean relations description language examples description experiments language ibm formal description algol report proposed string language january
january
inverse finite segment matrix january
numerical solution polynomial equation january
sorting procedures january
factors january
curve fitting constraints january
survey languages systems information retrieval january
semantic structure information systems january
translation retrieval requests english language january jr
language problems structured data january
language features make good symbol manipulation language suited types information retrieval programs presented general discussion unique programming language examination applications january
information ability intelligence data january
information structures processing retrieving january
discussion special language january
series december thacher jr
test matrices december
indexing lambda notation methods indexing stored elements sparse multi dimensional arrays scheme notation december
sort december
determinant december
assignment december
gauss december
topological ordering pert networks december
kutta december
minimum cost curve december
specification december
legal implications computers business introduction computers business wide variety legal implications merit attention early stage industry highly government subject important common law rules established legal significant processing essential identify provide legal aspects systems order avoid impact physical legal aspects business diverse states basic question law facilities directly questions relating processors respect information bank extent check government pertinent data processing service bank december
case study line savings bank application development line savings bank early conceptual bank design corporation bank equipment criteria development corporation operation line line programs statistics reliability performance bank discussed point view future line savings bank field discussed december
recent developments administration december
account classification december
application ibm methods calculation constants complex november
coding laboratory data automatic storage retrieval series laboratory codes developed store analysis test results automatic data processing codes constructed part computerized simulation handle results laboratory test encountered unique feature codes recorded test results test results coded paper describes codes developed presents analysis codes criteria developing codes outlined problem multiple terminology discussed solution problem flexible produced laboratory reports discussed report paper problems ten years practical automated information laboratory november
computation type functions november
length strings merge sort detailed statistics length strings result form internal sort phase merge sort tapes shown strings produced method produces strings long method produces strings statements previously literature modification read backward polyphase merge suggested november knuth
optimizing bit time simulation major component bit time simulation program boolean compiler compiler accepts boolean functions representing simulated digital circuits generates sets machine instructions executed techniques discussed increasing boolean compiler bit time simulation techniques applicable general purpose november
recent improvements programming language forms displayed formulas basic implementation language previous paper scientific compiler displayed formula language comm acm paper discusses recent improvements language areas complex display logical control area complex display improvements notation integration coefficients area logical control feature notation nested discussion notation procedures november
error parse november
flexible words language november
recursive programming fortran ii november
serial technique determine minimum paths november
interpolation differentiation integration november
euler summation november thacher jr
smooth november george
november thacher jr
bessel functions november
report discuss common programming languages november
usa standard information processing november
description language automatically programmed tools language numerical control programming notation introduced algol report examples usage included presented summary development statement present status november brown
inverse test matrix october
extension search variables technique search concepts developed solve optimization problems involving functions variables technique optimal sense dimensional search valuable kinds calculations october
comparison tapes principal characteristics current magnetic tape units summarized compared characteristics disk files illustrated sorting compared presented disk files tapes important applications october
disk file paper briefly describing ibm special emphasis organization operation input output equipment physical characteristics disk bit words word transmission rate noted timing limitations due motion disk discussed applications disk usage discussed separately problem programs systems programs compilers supervisory program approximately words disk storage storage systems programs subroutine library problem programs disk programming techniques discussed words disk core storage minimum arithmetic unit disk considered recovery mathematical physical developments calculation comments made reliability utility limitations disk future applications noted disk october
automatic data disk files space large scale automatic data facilities van includes remote input operating data central data processing center systems record control flow data data processing center large capacity data file store information required provide date information response received addition storage data disk files automatically records data magnetic tape input conventional line business data processing applications october
numerical method determination moving field curves treatment planning october
data communication computers ordinary operating users call ordinary special hardware required users input telephone output form results test area reported october
contour map program ray fortran program ibm plotter produce contour map matrix points dimension scale factors october
interpolation october
sort october
october
october
combinatorial things time time time october collins
combinatorial things time october
fourier series approximation october
october
evaluation integrals october gray
assignment october
integrals october gray
frequency distribution october gray
interpolation october
interpolation october
gauss october
discrete october jr
october boothroyd
partitioning algorithms finite sets partitions set elements represented positive integers generate partitions set partitions set fewer sets partitions set sets october
experiment automatic verification programs effective compiler explicit verification cost technique october
variable width character variable field computers permit manipulation variable width single machine commands variable field items availability variety field machine variable width item command operations made basis compiler algorithms proper machines class compilation advantages machines fixed length words october
format free input fortran october
report proposed american standard flowchart symbols information processing paper presents essential contents proposed american standard flowchart symbols information processing proposed standard prepared x3 problem description analysis american standards october
group representation algol symbols october
subset algol october
programmer members acm study concerned primarily attitudes programmers jobs high programmers choice field years principal job nature work jobs high level professional interest good working conditions satisfactory half report positive programmers programming part organizations primarily management principal factor programmers nature work offered principal job programmers expected programmers light function systems programmers applications programmers principal problems programming future languages specific applications techniques building programming october
group october
general program analysis square rectangular designs paper describes general purpose program handle incomplete block designs square rectangular flow diagrams method calculation programmed digital september
approximate solution dimensional problems numerically fast accurate numerical method programming details examples mathematical theory method natural dimensional problems means dimensional september
drawn flowcharts improved documentation written programs simple effective communication presented shown great programmer describes program simple format flow cross input description date easily final output original program proved valuable debugging coding aid september knuth
generalization algol september wirth
compiler based standard mathematical notation english version compiler operation features intended solution scientific problems presentation mathematical formulas standard notation english instructions automatic error diagnosis actual location error program attempt minimize fragmentation original problem statement normal feature programming systems september
symmetric list processor list processing list cell forward backward link intended higher level languages capable functions subroutines coded machine language presentation form fortran programs depending limited set fortran programs depending limited set primitive machine language subroutines defined finally set field character manipulation primitives round september
monte carlo inverse september
newton interpolation forward divided differences september thacher jr
newton interpolation backward divided differences september thacher jr
calculation divided differences september thacher jr
modified functions september thacher jr
series september
fourier series approximation september george
september
interest september
evaluation determinant september
evaluation determinant september
september
september
september
september
generation permutations order september
semi iterative process evaluating september
note matrices september
matrix eigenvectors september
note set test matrices inversion september
tape september moore
procedure converting logic table conditions efficient sequence test instructions september
monitor september
exponential method numerical integration ordinary differential equations formula numerical integration prepared involves exponential term formula compared standard integration methods shown large class differential equations exponential formula superior stability properties large step sizes formula large step size total computing time solution significantly engineering problems high accuracy needed august
program editing august
simulation traffic network august
structure pert programs introduction pert programs provided major components programs purposes outlined august
continued operation notation symbol manipulation array processing account device formal representation string relationships string transformation procedures computing procedures deal arrays functions variables device consists continued operation symbols summation symbol continued multiplication symbol conventional mathematics august
fortran august
note algol algol proposed eliminate statements language discussion background problem proof ambiguities included august jr
remarks syntax symbolic programming languages august
syntax controlled generator formal language processors august
reduction matrix polynomial elements august
orthogonal polynomial squares surface fit august
move plotting august
certification combinatorial things time time time comm acm august
certification combinatorial things time comm acm august
algebra sets august
combination order august
combination order august
august
matrix inversion august george
jacobi august naur
interpolation differentiation integration august
partition quicksort find august
set test matrices august naur
legendre functions kind real arguments august george
ii august
gauss method inversion ii august naur
august
august
august boothroyd
normal random august george
calendar date day number august
adaptive integration multiple integration august mckeeman
matrix division august
method finding roots arbitrary function august
august
august
character manipulation fortran august smith
multiple precision binary decimal integer conversion addition august moore
list structures august
list type storage technique information method economic terms space time proposed storage manipulation character strings arbitrary length fixed word length method illustrated application algol type algol block structure august
debugging systems source language level august
time sharing low cost serial designed built scientific department location magnetic drum main store avoid optimum programming techniques increase efficiency word core store program core drum paper tape input output time shared multiplication division orders machine executing orders simultaneously functions number advanced orders facilities execute order permits jump orders register permits double modification general relative addressing subroutines effective speed machine basic specification lead design concepts time sharing incorporated low cost computers august
american standard code information interchange august
entry retrieval july
design transition compiler cobol compiler design presented compact permit rapid pass compilation large subset cobol large compiler smaller machines require working tapes compiler tape methods applicable construction algol compilers july
linking segment language linking july
squares solution constraints july
july
july evans jr
series algorithms july thacher jr
newton july
certification matrix inversion procedures july
series july
july
july
complex power july
july
july
differences derivatives july
complex arithmetic july
normal probability curve fitting july
probability curve fitting july
july
boolean ibm july
polynomial evaluation revised july
checking loops networks july
remarks sampling tape file iii july
real time programming specifications problems implementation large real time applications suggested guidelines program file specifications developed problems occur systems programming july head
syntactic description july wirth
automated descriptive geometry descriptive geometry consists procedures designed solve space geometry problems graphical measurement computation addition approach problems call subroutines compute graphical advantage approach descriptive geometry accuracy computation speed digital makes program problems space statements consists subroutines procedures descriptive geometry june
interpretive program analysis data operating program processes recorded data input program consists high recorded program automatically measures preliminary interpretation continuous operation processing rate achieved june
remarks fortran subroutines time series analysis june
disk file sorting sorting techniques ibm random access storage device evaluated june
flow network calculations general method calculation flow networks presented method applicable june
external language digital june
computing language june
real error function june thacher jr
curve fitting constraints june
reduction symmetric form june schwartz
nonrecursive adaptive integration june mckeeman
error function large june thacher jr
error function large june thacher jr
incomplete ratio june
direct search june jr
squares solution constraints june
squares surface fit june
sort june
bounds polynomial june
june
fortran feature june
test matrix june
inverse conversion table june
matching program logic matching program written june brown
note range transformations square root logarithm idea previous papers years functions desirable transform argument short range symmetric give examples usage square root logarithm function binary decimal machines june bemer
tree structures processing files data processing problems files frequently binary search techniques efficient searching large files file organization readily file file allocation permits efficient efficiently file organized tree structure discussed shown file times proportional number file items parameter tree shown optimizing search time binary search tree organization employs data considered organizations binary search file relation tree organization multidimensional indexing structure discussed jr
conversion comparison techniques variable length sorting logic converting highly variable input records format easily efficiently processed sorting program internal record discussed relation conversion input output comparison techniques internal
design characteristics variable length record sort fixed length record sorting techniques paper describes application techniques sorting fixed length records problems variable length record sorting techniques implemented fixed length words memory specifically techniques sequence variable length records size produce long initial strings data merge strings data power number work tapes volume input data
method comparing time requirements sorting methods
cobol sort
characteristics sorting computing systems random access storage devices substantial differences characteristics random access storage tape devices concepts objectives program design considered external file medium true case sorting tape oriented major sorting problem minimizing merge time limited orders merge sorting random access oriented selection optimum order merge orders problem discussed paper criteria developed determining optimum order merge properties random access storage devices attention problem key sorting record sorting possibly key sorting random access
organization structure disk file memory systems efficient sorting data processing programs approach organization structure data file memory systems sorting performing data processing functions presented areas characteristics file systems proposed chaining structures data functions disk file executive routine concepts sorting performing file maintenance processing proposed structure executive routine discussed shown sorting accomplished disk storage work areas
sorting large volume random access drum storage approach sorting records random access drum memory sort program designed generalized generating sort applicable variety record statements description divided parts part presents operating environment general solution part describes internal sort merge technique jr
sorting files techniques fact compiler typical file structures including called redundant examined methods fact sort files discussed
tape file merge pattern generator routine presented sequence merge cycles effect merging tape files routine designed minimize time power merge cycles tape characteristic drive single file multiple file
comparison polyphase sort techniques comparison polyphase sort techniques developed systems ten tape basis comparison total writing required number input strings tape techniques
read backward polyphase sorting read backward polyphase sorting efficient tapes sort sorting techniques backward polyphase produces continuous merging process tapes total number tapes sorting process techniques conjunction polyphase merge sort provided capability producing strings strings tapes required polyphase merge
string distribution polyphase sort jr
sorting
empirical study minimal storage sorting
internal tape sorting replacement selection technique general technique sequencing records presented technique shown applicable stage generalized sort program initial strings sorting records memory storage internal sort shown records memory storage records log2 tests record initial string lengths average 2n random input records writing processing accomplished simultaneously permits overlap
sorting computers gotlieb
squares fitting surfaces dynamic programming dynamic programming recently bellman determine fit line segments curve interval number segments fixed present paper successive models developed extend method fitting plane segments surfaces defined types space model considers rectangular area plane segments defined space shown model incorporated successive approximations optimal type closed area finally applications briefly april
suggested method making strings algol april brown
term square april
term square april
april thacher jr
adaptive numerical integration simpson rule april mckeeman
random april jr
chebyshev april
incomplete elliptic integrals april van
complete elliptic integral april thacher
complete elliptic integral kind april thacher jr
reduction matrix polynomial elements april
newton interpolation forward divided differences april
newton interpolation backward divided differences april
calculation divided differences april
monte carlo april
complete elliptic integrals april thacher jr
orthogonal polynomial squares surface fit april clark
modified function april
move plotting april
combinatorial things time time time april
combinatorial things time april
actions algol programming language april
selected definitions selection definitions prepared acm standards committee programming terminology presented acm april
information retrieval information retrieval problem solution presented technical library limited solution general applicable types retrieval problems method solution makes groups previously information retrieval program difficult programming point position present solution makes information retrieval program equipment
retrieval command language scheme retrieval manipulation data file records language scheme selecting file records logical condition statements defining record classes file records editing printed output results operations examples typical file application significant features machine implementation
significance arithmetic digital modified include significance mode operation intended facilitate identification significant bits results floating point arithmetic operations manner floating point arithmetic handled mode discussed numerical experiments mode comparisons made ordinary mode examples include power series evaluation linear equations solution determinant evaluation matrix inversion
iterative factorization technique polynomials iterative technique displayed factors arbitrary degree found polynomials variable convergence shown occur initial approximation factor actual factor process simply programmed preliminary results digital computers factors degree technique similar present method simpler
computational extension difference method presented computational extension difference method developed
characteristic values vectors matrices
note proof existence phrase structure grammar algol brown
random
square
thacher jr
difference expression coefficients clark
determinant
series
fourier series approximation
algebra sets
combination order
combination order
test matrix inversion
declarations corrigendum
selective instruction
method file searching
addressing array dimensions fortran analysis variance
neliac
documentation
documentation
fortran
cobol
documentation problems algol naur
documentation programming languages
incomplete elliptic integrals
thacher jr
location vector ordered
linear programming applied
character manipulation fortran
construction
decimal binary conversion short fields
systematic analysis digital programs
matrix inversion gauss inversion ii january naur
squares january naur
gauss method january naur
calculating means january naur
set test matrices january naur
inverse finite segment matrix january naur
january naur
gamma function january
generating discrete random variables note concerned details things assigned probabilities method uniform variable direct memory location sequence chosen conditional probabilities efficient memory space fast programs result january
recursive program general dimensional integral general program outlined dimensional integration variable program recursive nature simpson rule combined required accuracy developed scheme january
fortran subroutines time series analysis authors recently concerned time series study typical applied statistical research involving extensive computations large data found numerical processes required built completely small number basic operations set fortran subroutines written perform main purpose note describe subroutines question general statistical programs include general remarks january
terms frequently combined problem description january
storage search properties tree organized memory memory list properties construct numeric trees trees information storage retrieval properties applicable problems involving large quantities data problems word length distribution stored information processing purpose paper storage search properties tree organized storage memory list properties prime interest application symbol table dictionary similar file stored january
declarations application cobol january
suggestions algol issues report american standards x3 january
algol report january
note procedures december
integer constants algol remarks relations syntax semantics programming languages point true grammar context free language strings generating device method meaning grammar algol open december
parallel methods ordinary differential equations paper order full advantage real time computations highly parallel computers expected future numerical analysis parallel form serial algorithms computed knowledge results method proposed numerical integration ordinary differential equation process standard methods serial december
rational chebyshev approximations bessel function integrals approximate integrals rational functions related coefficients approximations december
fortran ii chaining december
scanning text december
note calculation probabilities distribution december
class matrices test inversion procedures december
family test matrices december
method partial magnetic tape december
case precision december
mark sense programming inputs december
curve fitting format fortran december
limited bit manipulation fortran ii techniques developed manipulating bits fortran ii techniques individual bits tested fields numbers coded binary december
double precision squares root cdc january summary approximations elementary functions cdc approximations techniques suggested applicable large cdc line built double precision floating point arithmetic present work extension ideas double precision subroutine december
relative effects central processor input output large presented paper technique determining relative effects internal speed speed input output units speed equations derived permit determination effects hardware usage measurements december
algebra coefficients theoretical table formulas integrals involving legendre functions constructed program performed algebraic operations formulas rational algebraic expressions single variable constructed recurrence procedure interest coding techniques write relevant programs fortran results controlled tapes punched directly output avoiding manual errors correction december
greatest common divisor a1 december
evaluation determinant december
error function s15 december
inverse random point sequence g5 december smith
december boothroyd
m1 december floyd
time sharing traffic control program traffic signal control consists variety distinct programs machine time satisfy time sharing program written purpose execute order priority real time paper interesting aspects time sharing program outlined november
executive implemented finite state command control permits operators access large data files man machine interface satisfied communication operators queries view data link permits remote messages status reports directly information received line data link update data files stored disk programming divided executive control program components processing permit sensitive console inputs permit operators time share central processor executive control program control programming components major emphasis paper technique definition finite state organizing executive control program november
estimation parameters potential measurements fundamental problem vector estimation state basis potential measurements mathematical model relating surface shown inverse problem determining parameters basis potential measurements viewed nonlinear boundary problem feasible solution employing high speed digital computers november bellman
technique tapes makes analysis feasible ibm study higher frequency components long series cycles examined valid comparison made technique presented automatic analysis long series cycles digital november
program work standard vocabulary computers information processing november
integrals november gray
calendar date day number november
integrals november
logarithm complex number november
multiple precision arithmetic exact calculation symbols paper general purpose multiple precision fixed point routines subroutines mechanical symbols large arguments november
rounding problems data processing common requirement data processing sum set numbers generally manner equal sum numbers rounding procedures procedure depends numbers sign sum sign number rounding november
inductive approach language translation possibility natural language translation means fixed operations considered sentence translation work presented measurement physical similarity pairs strings discussed notion central role proposed type translator experimental evidence presented support based november
tape information interchange proposed american standard october
report input output procedures algol october
report subset algol october
proposed proposed american standard specification general purpose paper information processing october
fortran basic fortran programming language information processing automatic data processing systems october
history summary fortran standardization development october
method syntax specification october
type statements programming languages proposal made including programming language statements relations variables explicit assignment statements compiler sets iteration making purpose routine formal differentiation october
gamma function accuracy s14 october
gamma function s14 october
kutta october
m1 october
e4 october
permutations set g6 october
protection programs october
programs october
computers october
october
aspects usage paper concerned question work work analyzed partially utilized produce output question programs programs discussed paper directed primarily discussion present law aspects proposed law included general recommendations made respect proposed law october
rapid method digital time time series analysis minimum multiplication method digital line real time analysis data constructed readily components manner frequency response curves includes good low pass pass designs programs implementing synthesis application computers definition recursive macros september
analysis method systems detection rapid correct data handle relaxation times program developed distribution function time distribution step subroutine state action produced program based direct statement fourier law rate equation provide law flow distribution analysis method physical process explicitly program results mathematical procedures program tested exact solutions equation identical results compared experimental data construction programs based direct statement physical principle general applicability applied physical september
september
september
storage allocation reference structure method proposed discussed variable capability fortran sense added type assembly systems september
extension existing compilers sophisticated macros description presented application macros string employed facility september
scheduling scheduling papers developed american experimental scientific united states technique developed applied schedule parallel september schwartz
solution combinatorial problems generating functions variable field utility generating functions solving combinatorial problems discussed implementation results presented evaluated september
computation facility education research present day computing facilities limited scientific research strongly users full power research computing terminals give user ability generate correct operate procedure simple complex implementation small scale permits users work independently machine obtain satisfactory response typewriter communication september
logarithm complex number august
formal parsing systems automatic syntactic analysis recently important natural language data processing syntax directed compilers formal parsing consists finite map recursive set strings called syntactic sentence classes program automatic syntactic analysis determines formal parsing directed production analyzer nondeterministic pushdown store machine internal vocabulary input vocabulary productions form elements set element set context free language analyzed directed production analyzer multiple path syntactic analyzer english directed production analyzer working parsing connection structures assigned analyzer conventional phrase structure grammar examined paper august
final examination scheduling method scheduling final examinations yield minimal number student conflicts minimization achieved evaluating nonlinear set equations process random monte carlo selection heuristic techniques solution optimum solutions found yield minimal results programs empirical results august
machine analysis variance major problem analysis variance number factors increases exponential number interactions interactions experimental designs problem error terms natural handle work involved computing interactions program device august
minimax polynomial approximations partitioning intervals method minimax polynomial approximation product method formula estimate maximum error degree approximation formula partitioning obtained basic interval approximations equal degree give equal maximum error august
tape variable block numerically controlled machine tools proposed american standards august
comments bit sequencing ascii serial bit data transmission august bemer
gauss s15 august pike
move plotting august
free field read august mckeeman
method f4 august
greatest common divisor a1 august
bessel functions kind august gautschi
note free list august
method syntax checking algol syntax designed based syntax algol algol report communications acm definition elements language recursive desirable design syntax set recursive processors subroutines perform functions recursive nature language syntax problem recovery error required attention method permits programs completely errors august
correct methods multiple precision division division problem defined notation problem multiple precision operation digital introduced basic correct method multiple precision division formulated properties briefly reviewed interest fact method produces step set estimates desired result exact august
method august
investigation analytical method numerical derivative evaluation recently proposed analytical approach numerical derivative evaluation discussed technique shown accurate easy modifications required greatly facilitate writing debugging programs requiring derivatives highly complex functions august
simple automatic derivative evaluation program procedure automatic evaluation total partial derivatives arbitrary algebraic functions presented technique permits computation numerical values derivatives developing analytical expressions derivatives key method decomposition function introduction intermediate variables series elementary functional steps library elementary function subroutines provided automatic evaluation differentiation variables final step process produces desired function derivative main feature approach simplicity tool derivation analytical derivatives debugging tool programs derivatives august
techniques simulation logic simulation digital integral part design systems evaluation boolean functions simulated major portion simulation general classes evaluating functions defined greatly increased efficiency simulation methods presented simultaneously evaluating functions set values variables evaluating simultaneously function sets values variables july
note starting newton method determination suitable initial estimate root equation means computing roots sequence related equations july
theoretical considerations information retrieval systems information storage retrieval systems major components identification information effective retrieval searching strategy file scanning material file organization make access information efficient identification information paper suggests recently discussed paper object language searching strategy linear model evaluation function developed retrieving relevant documents retrieving relevant documents linear model approaches file organization discussed organization file based history past performance generating subset file high probability relevant july
experimental array translator designed man machine interaction general purpose problem solving environment operational array oriented symbolic source language powerful statement types include numeric boolean relational selection operators entire arrays permits simple specification test argument arrays single statements completely symbolic operating includes display entry program data sequence control aided interrupt user program execution addition normal stored program sequencing trace ability statement execution present implementation interpretive translator ibm july
automated data analysis technique technique designed principal problems current analysis large data long time project operational date lack explicit directions data analysis results lack technique control data analysis determining workload relationships storage characteristics documents information network automatically july
characteristics fortran language fortran languages fortran ii variety modes real quantities suitable input output list expression quantities occur modes makes address greater number input output equipment restrictions complexity list quantities magnetic core memory drum magnetic tape units july
generalization algol july
reduction matrix polynomial elements july
iteration f4 july mckeeman
summation fourier series c6 july thacher jr
romberg integration d1 july thacher jr
random permutation g6 july
poisson polynomials july
high level source language debugging technique real time data extraction meaning debugging technique aids substantially debugging complex real time programming systems users program desired points previously data data data high level source language identification july
automatic subroutine method automatic loading library subroutines operate conjunction conventional pass method specifically designed nested library structure july
programming analysis variance sequences operators special operator calculus developed mapping scheme found efficient programming analysis variance experiments operator calculus mapping scheme detail july
compiler building developed morris number published past years morris recent paper presented interesting programming developed present paper describes major features points original authors cover briefly topics considerable space purpose paper small details comments material published references july
generation test matrices similarity transformations method obtaining test matrices distribution characteristic roots process consists simple similarity transformations generate full matrices forms matrices generated characteristic vectors june
approximate solution symmetric problems variety physical problems diverse fields field theory flow theory reduce assumption study elliptic partial differential equation type problems equation studied regions include portion accurate numerical methods approximating solutions june
numerical solution nonlinear point boundary problems finite difference methods solution nonlinear point boundary problems extremely difficult task questions established numerical technique problem present techniques method problems difficult method finite differences obtain solution paper examples discusses finite difference method linear point boundary problems june
parts technique list structures list structured parts proposed discussed implementation presented operating program techniques june
list items list concept proposed single words elements list report describes consecutive words element results considerable space required amount data execution time required perform process data description standard list structures single word items items introduced variable length items space utilization problems finally examples illustrate lists paper attempts recent papers applied concepts ways general problems june
reducing truncation errors programming sum numerical integration large number intervals sum larger individual produce accurate sum number intervals increased separate variables established partial sums distinct intervals extensive successive eliminated june
design implementation general purpose input routine general purpose input routine discussed fortran philosophy programs examined june
gauss june
bessel functions june
june
critical path scheduling june
simpson rule multiple integration june
june williams
matrix inversion june boothroyd
matrix permutation june boothroyd
symbol manipulation fortran subroutines set subroutines fortran purpose output strings input strings analyzed general syntactic analysis subroutine reported earlier ii strings formed function type subroutines included intermediate performed strings stored internal representation automatic internal representation created stored block common storage manner storage block purpose discussed june
paper tape information interchange proposed american standard june
tape code information interchange proposed american standard june
bit sequencing american standard code information interchange ascii serial bit data transmission proposed american standard june
applications linear programming linear programming models recent years concept organizing code change longer reduce mathematical simplex method code advanced code variety situations organized integrated emphasis paper underlying principles future linear programming systems based applications industry systems components translation problem statement terms basic data linear programming matrix coefficients data transmission direct entry data file center data processing editing solving simplex efficient reliable code solving mentioned flexible means results june
picture generation standard line method producing gray pictures line standard characters gray levels images cells display technique
fortran ii load time
method comparing internal operating computers collins
input card
usage accounting generalized time sharing systems current development general time sharing systems requires accounting procedures usage time sharing users operate precise amount time storage space user cost factors considered usage accounting generalized time sharing systems discussed
improved equivalence storage basis equivalence dimension common declarations presented based tree structure reduced computation time percent previously published equivalence classes scan equivalence declarations method applicable problem identify equivalence classes element pairs defining equivalence relation galler fisher
fast procedure generating exponential random variables fast method generating exponential random variables digital outlined
multiple integration wirth
chebyshev curve fit naur
elementary functions continued
bessel functions
chebyshev polynomial coefficients
normal distribution function
gamma function controlled accuracy
experiment user oriented version software hardware purpose programming analysis formulated problems modified generate input equations requests manner conventional mathematical language rules flexible compiler part efficient aspects tool study problem solving teaching systems
coded existing programming languages handle character strings mentioned scheme additional proposed scheme left sequences numeric sequence variations character size number bits arbitrary source language character representation
specification general purpose paper information processing proposed american standard
proposal input output conventions algol report algol acm programming language committee
problems automatic variety problems design operation automatic discussed purpose general view major problem areas attempt made discuss details alternative solutions april
planning code developed finding minimum cost combinations items production requirements satisfied sequence fast special integer programming theoretical solution problem line percent cost fortran program ibm request considerable amount data processing implementation april
designing center april
incomplete function april gautschi
april thacher jr
nonrecursive adaptive integration april
evaluation determinant april
prime april
decimal tables binary coded tables april
avoiding matrix fortran ii fortran iv april
converting integers base base simple integer conversion number systems presented proved april
comparison list processing languages including detailed comparison lisp slip detailed comparison presented lisp slip programming languages principal characteristics existing list processing languages important common features list processing languages reviewed forms data structures dynamic allocation storage pushdown recursive operations principal differences languages consideration detailed representations data programmer machine methods storage allocation programming special processes including arithmetic facilities terms availability documentation learning aids debugging facilities comparison shows languages discussed approximately speed finally authors give heuristics aid selection languages problem applications languages considered superior list processing applications april
professional work blind developments technology professional blind blind offered including programmer important future planning interest fact blind suited programming work training constant experience objects environment memory blind work programming result fewer debugging problems make blind valuable addition systems group blind professional number aids techniques developed machines programmer paper describes techniques aids designed computing center university april
status sciences curricula colleges universities april
place logical design switching theory curriculum april
mechanical languages specification april
logic sciences april
undergraduate curriculum numerical analysis april
introducing digital computing april
programming digital computers april perlis
computers education april
digital data processor partially study techniques feasibility technique selected conducted define line center partially data processing portion presented detail general operation head assembly data operation entire effect data processing considerations design consists digital drive mechanism units connected control loop application mechanical scanning mechanism read line measurement information information read special purpose digital measurements error drive
conversion power series chebyshev polynomials power series series chebyshev polynomials sequence transformations evaluating coefficients method illustrated computing coefficients expansion logarithm thacher jr
fourier series method numerical solution class partial differential equations fourier series method applied class partial differential equations reduces problem ordinary differential equations application method shows considerable advantage conventional finite difference methods
class iterative techniques factorization polynomials method iteration developed terms function arbitrary character sufficient conditions convergence process factors arbitrary degree polynomials variable method newton method occur special cases
technique detection correction spelling errors method word found dictionary error single transposition input word compared dictionary testing time words match errors test run text correct made percent error types
made perspective scientific communication tool easy program basic transformation required perspective drawing fact high speed general makes perspective direct output programming briefly control represents represents cost approximately ibm time
generating encoding programs generating minimum redundancy encoding program generates frequency tree determines structure functions encoding program codes schwartz
binary searching tree structure efficient method tree structures proposed search path significant result search key includes characters jr
tests method constructing school previously proposed method constructing based iteration involving boolean matrices limited tests method successfully produced references timetable problem theorems matrices zeros theorems graphs problems method constructing real situations noted gotlieb
polyphase sorting variation polyphase merge technique sorting permits tape time merge continued tapes result major portion time technique considered sort written operate tapes read savings overlap method increase number tapes increased
fortran subroutines time series data reduction
open x3 fortran standards american
group representations algol symbols comm acm
comments continued operation notation note intended correct points recent paper describing symbol manipulation comm acm august
note compiling algorithms compiling generators arithmetic expressions discussed experimental compiler improvement suggested
gauss
matrix division
naur
tridiagonal matrix naur
evaluation determinant
incomplete function gautschi
gamma function gautschi
context ambiguity parsing
extension algol manipulating perlis
programming package general modes arithmetic
effects language structures problem compiling efficient codes development intermediate language structure machine easily improving object program efficiency subject paper intermediate language methods manipulating series arithmetic statements discussed assumed functions statements simple variables purposes simplicity treatment simplified structure presented illustrate compiling method assumptions made purposes simplification cases assumptions actual machine
general business oriented language based decision expressions structure digital compute programming language wide class business file processing applications presented structure based incorporating compiler aspects common processes class permits writing extremely compact programs complex applications terms tables control expressions information characteristic application local process output files involved local modifications program modification entry tables structure preparation loading speed compilers source programs efficient machine codes approach conventional mechanical language design structural analysis class processes represented languages formal contents independent definitions nonprocedural representation process sets tables relations data results control statements procedure descriptions flowcharts invariant pattern procedure identified characteristic class batch file processes philosophy potential business oriented languages fully requirements set languages including machine independence
theory information handling jr
format language perlis
formalism programming languages
fortran iv syntax language
structural formal language
bounded context syntactic analysis floyd
extension algol languages
analysis type data comparative study made variety numerical techniques fitting experimental data type forms involving sums statistical errors parameters calculated methods applied generated sets data results experiments human results show values parameters sensitive variations fitting procedure great sensitive variations fitting procedure great values physical constants values functions derived parameters physical generally stable variations fitting techniques error bounds large great uniform technique running experiments analyzing data significant relative results subject january
digital determination source activity technique determining activity source technique digital applications field physics technique involves manipulation digital image source experimental details january taylor
heuristic program testing pairs directed line graphs pair directed line graphs problem efficient algorithmic solution straightforward require years running time high speed order compare node graphs sophisticated approach called situation similar areas game theorem proving practical algorithms interesting cases practical partially successful techniques graph variety processes attempt search demonstrate exists scheme solution program designed avoid computation lines written language successfully tested ibm january
efficient formula multidimensional quadrature point degree quadrature formula integration dimensional rectangle presented points surface sign points large volume rectangular point required achieve degree accuracy january thacher jr
numerical solution boundary problems linear ordinary differential equations numerical method presented solution boundary problems involving linear ordinary differential equations method makes step numerical integration scheme reduce problem boundary values initial values comments made numerical results method specific problem addition extension general problems discussed january day collins ii
significant digit arithmetic methods handling process geometric series shown give results widely carried machine incorporating significant digit arithmetic january
language compiler writing january
fortran procedure january
note boolean matrices ii january
floating point arithmetic bit numbers straightforward technique presented limited size type number representation multiple precision arithmetic january
fast procedure generating normal random variables technique generating distributed random numbers faster general readily applicable binary decimal computers january
multi tape infinite state automata survey survey machines powerful finite automata powerful general turing machines presented machines related digital computers finite automata turing machines intermediate machines created infinite state memory finite state machine performing manner portion memory accessed bound number steps allowed computation increasing recursive function length input total amount memory manner examples classes properties discussed december
experiments question answering program investigation artificial intelligence experiments question answering run lisp program called questions fact specific information method answering general kind question conclusions drawn article answer wide variety questions human increase power write simple programs ability ability program learn search procedure present questions questions relevant order present method making logical calculus equivalent redundant december
function december
procedure normal distribution functions s15 december
program structures parallel processing constructs organizing parallel program segments discussed extensions algol constructs serve meta commands equipment multiprocessing capability december
machine independence technology survey offered techniques programs compilers methods examined technique detailed discussion emphasis considerations determine applicability specific case discussed attempt made finally reasons machine independence problem substantially current design process convergence hardware design software developments lead satisfactory resolution december
aided translation semi automatic translation implemented language programs assembly language input program prepared translation user output consists language program comprehensive diagnostic user order areas translation translation processor consists distinct assembly program comprehensive analysis code regard actions instructions instructions data finally output pass generates program form macro instructions december
compatibility feature ibm model generation stored program computers ibm series part time large scale rapid technology rapid data processing equipment program written required conversion machines ibm designed conversion problem specifically conversion aids model compatibility feature feature conjunction aids permits smooth transition optimum december
assembly language complete compiler language programs assembly language programs present greatest difficulty assembly languages generally provide translation symbolic numeric version program assembly language machine language meta language presented mapping language list form arbitrary bits bit machine language program character user meta language map assembly language assembly language machine machine language december graham
ibm translation problem oriented symbolic binary levels translation developed eliminate effort required series codes ibm operation experience limited highly successful application techniques source object languages december
large systems conversion problem technique called discussed technique developed includes sections central processing unit cpu input output unit general treatment sections describe greater detail implementation compatibility features techniques ibm systems ibm december
aid object program run object code execution rates considerably traditional simulation increase capacity user makes hardware program routines software routines function december
macros translation symbolic assembly language set macro operations prepared assist ibm symbolic assembly language programs ibm machine language programs set symbolic instruction macro instructions produce equivalent instruction sets instructions basic operational classes expressed single basic skeleton levels macro calls required arguments basic skeleton instruction modification execution time address instruction requires address equivalent handled generating calls simulation subroutines december jr
translation machine language programs automatic translation machine language programs highly desirable goal large scale computers make difficult achieve completely automatic analyzed shown primarily semantic nature semi automatic procedure semantic problems suggested december
machine lines cobol production large file maintenance retrieval program written cobol cobol language specifically operate ibm computers december
minimizing functions partially presented solving problem automatic layout ordered set e2 components permutation elements e2 integer function local minimum evaluating set set performed process set positive set proved minimum procedure similar method finding minimum real function applied problems experimental results presented formed elements initial november
analyzing english syntax pattern learning parser analysis based pattern recognition learning logic developed word classes rules syntactic combination experience text analyzed characteristics form word classes depth tree word features syntactic rules combination show relation word depth pattern sentence tested elementary basic english sentences including earlier learning parser sentences experience sentences percent accuracy learning sentences probability accurately parsing sentence encountered concluded learning parse basic english development required conclusions application ordinary english stored operational time shared computing november
comparison primal simplex primal dual algorithms linear programming statistical comparison primal dual commonly primal simplex solving linear programming problems made assumption starting full artificial basis conditions primal dual method shows statistically significant generated problems found regression analysis relevant parameters determining difference number algorithms number constraints number variables ratio november
conversion limited entry decision tables programs decision tables describing set complex decision rules based sets conditions algorithms efficiently convert tables programs extend usefulness decision tables users algorithms based work extended handle decision rules minimizes storage space required resultant program minimizes running time conversion process rules table november
performance automatic segmentation programs algol compiler algol algol compiler makes automatic handling program segments drum store core store program execution time logic performance discussed primarily basis execution times related specific programs discussion potential ways improving november naur
inverse permutation g6 november
m1 november
finding eigenvectors gaussian elimination f2 november
determinant evaluation november
algol reference language editor november mckeeman
university fast fortran translator core compile designed ibm half word core memory monitor job sequencing translator full fortran iv language fortran subroutine library input output compile time execute time diagnostic message writing routine small medium fortran iv source language programs processed high language compatibility programs run november
language string transformations language designed data manipulation data linear form workspace table axioms called transformation consists matching procedure applicable replacement procedure part workspace applied definitions symbolic terms presented table process definition includes special case recursive assertions complete programs show applications language november
simple data transmission telephone method data type laboratory situation direct central method requires specialized equipment ordinary telephone basis present applications include output calculations activity studies time sequence studies october
experimental obtained hypothesis words common contexts word contexts word function degree similar meaning functions similarity context reliable criterion detecting pairs words similar meaning october
note digital algebra programming special purpose compiler written fortran ii language made writing long programs procedure based forward format statements generating machine written programs october
fast storage fast storage method list structure operations situations involving sizes blocks fixed size location scheme bell telephone low level list language makes blocks registers sizes smaller blocks obtained larger half larger blocks parts simultaneously free october
program solve problem recursive macros coding technique macro instructions lists arguments discussion primarily technique solve problem problem fitting plane area formed squares october
recursive solution class combinatorial problems combinatorial problems requiring selection elements set elements solved recursion process computing coefficients specific problems analyzed general technique algol program developed problems october
note ascii code table standards october
algol design language idea constructing design language making algol programming language presented designer design language higher level user higher level programming language purposes requirements design language achieve purposes translator required design logic set boolean equations design language presented terms vocabulary statements sequences included examples expressions binary operators statements transfer statements terminal statements statements statements statements statements sequences october
random normal g5 october pike
pseudo random numbers g5 october pike hill
find precedence functions october wirth
interpolation table october
october
acm principles applied operation history acm moore school university reviewed briefly principles presented information services easy information files users file organization service user costs principles serve acm main features information direct user access line console direct user access details organization search vocabulary user access document indexing stochastic search linked index terms file relationships acm documents relating primarily early research compilers documents computing indexing detail main describe documents inverted lists provided retrieval concept coordination october jr
university linear file series programs developed operational processing national space administration linear file ibm combined data processing program note create fixed length logical records fixed length blocks variable length source data format output optimization processing ibm programs completely checking test accuracy input provided national space administration september
applications differential equations general problem solving large class problems leading digital processing formulated terms numerical solution systems ordinary differential equations powerful methods existence solution systems good general purpose routine solution systems powerful tool processing problems true point view ease programming ease debugging minimization time number examples discussed detail september
finding zeros polynomial method simultaneously zeros polynomial developed tested number polynomials real coefficients method quotient difference starting values newton rapid convergence sufficient conditions existence scheme completely occur zeros equal equal achieved cases equal difficulty cases roundoff result errors scheme give zeros find september
solution problem concurrent programming control number independent sequential cyclic processes restricted means communication made critical section cycle september dijkstra
center simulation project today computation based changing hardware software systems difficult base decisions experience comparable experience problem situation paper mathematical model central center formulated describes operation computation center terms information decision processes control functions experiments performed model results experiments application results discussed september
subroutines computers run design describe permits subroutines executed backward forward instructions instructions shown concept number subroutine types developed properties properties matrix operations parallel suggested classification september
generation permutations graphical order g6 september
normal random g5 september pike
g5 september pike
character structure character sense serial bit data communication american standard code information interchange proposed american standard september
undergraduate program science preliminary recommendations september report acm curriculum committee science
method curve fitting oriented method processing communicating numerical data reliability factors define reliability measured item information compute maximum permitted error values principle information compute values parameters terms data compatibility tests number equations made problems easily solved design experiments greatly simplified computational mathematical techniques reduce discussed statistical graphical methods curve fitting noted august
remarks simulation boolean functions august
simulation logic fortran arithmetic august
fortran ii programming ibm august
file handling fortran note describes fortran subroutines facilitate handling tape files symbolic information files scientific programmer idea simplicity comments years subroutines august
note storage strings method storing strings blocks size completely dynamic relation similar schemes discussed august
linear point boundary problems suggested convergence properties usual successive approximation scheme improved techniques numerical provided august bellman
dynamic format specifications implementation fortran format discussed format types give fortran programmer control input output specifications execution time august
experiments algebraic manipulation set subroutines algebraic ibm written list processor slip series problems increasing difficulty solved routines august
techniques algol compiler written group ibm significant techniques compiler writing details compiler timing estimates compiler requirements august
symbolic derivatives list processing subroutines recursion routine developed symbolic derivative continuous elementary function variables made list processing languages chain rule applied result produce results efficient obtained hand computation subset formula translator differentiation operator algebraic programming language august smith
map partitions integers a1 august mckay
partition generator a1 august mckay
number restricted partitions a1 august mckay
symbols august
symbols august
legendre functions arguments larger august gautschi
high speed compilation efficient object code pass compiler properties briefly scan intermediate language produced pass essentially reverse order generated pass read problem oriented input double scan performed compiler constant expressions expressions loops important part common recognition optimization effective index registers important discussed object code efficient highly machine dependent discussion terms fortran language technique applicable algebraic languages august
determining computing center environment investigation generally parameters descriptive computing center environment obtained actual data collection reduction results collection summarized july
analyzer path elimination technique characteristic features analyzer syntactic analysis operational ibm advantages discussed comparison analyzer developed corporation english grammar addition technique path elimination analyzer efficiency processing time core storage requirement july
organization structured files data file integral part data processing systems selection organization data file critical operating efficiency paper systems designer information source describes ten techniques employed organizing structured data characteristics organizations application independent providing designer reference number file organizations july
july
m1 july
random permutation g6 july pike
method end printed line description method presented result application general rules character sets considered routine method briefly outlined july
optimization redundant instructions final stage compilation simple optimizing technique called optimization method july mckeeman
representation standard bit code punched standard july
conventions symbols preparation flowcharts information processing systems standard working paper paper intended outline conventions considered flowcharts information processing systems conventions applied symbols proposed american standard flowchart symbols symbols july
structure algol compiler high speed top method syntax analysis completely back source string implemented convenient macro language technique simulation compile time conventional run time stack enables generation code expressions minimizes stack motion run time recursion side effects procedures block structure recursion handled interpretive methods run times context problem transmission recursive procedures parameters called solved manner permits handling common cases simple expressions array efficiency july
stochastic approach coding english program word english text form class part speech program operates high speed limited storage space half word events identified small dictionary function words frequently lexical words tests logical decision rules employed code additional words finally words assigned class basis form classes occur identified contexts conditional probabilities basis coding derived separate hand coded preliminary accuracy obvious ways improving suggested analysis results june
automatic document retrieval fully automatic document retrieval operating ibm characterized fact methods documents search requests feature retrieval process exact sequence operations search strategy individual users actual operating environment test effectiveness processing methods results obtained combination analysis procedures general information typical search request present report illustrate systems operations evaluation procedures june
conversion decision tables programs translation procedures conversion decision tables programs presented evaluated terms storage requirements execution time compile time procedures valuable hand coding algorithms compiler limited entry extended entry tables analyzed addition table analysis nature table oriented programming languages features discussed familiar nature decision tables conventional definitions june
technique integrated reports multi run requirements accounting included simultaneous requirement accounting requirements definite problems design handling function practical satisfactory solution developed basic service runs report production runs permitted final easy efficient production changing requirements june
june
june
d1 june
modified method june
testing understanding difference call call algol june
bit manipulation fortran language june
fortran june
nested june
operating environment dynamic recursive programming systems presented paper introduction programming serve operating environment dynamic recursive programs programming systems services include dynamic allocation storage blocks arbitrary size input output hierarchy data types public pushdown list automatic recursive programming compiler subroutine communication debugging aids june brown
automatic simplification programs presented paper problem writing program program perform argument program form knowledge june
recorded magnetic tape information interchange revised proposed american standard june
graphic symbols problem definition analysis standards working paper june
american standard compared proposed american standard vocabulary information processing vocabulary terms information processing analyzed compared june
symbolic statistical tables approach automatic design preparation statistical tables important function data processing systems organizations symbolic notation description tables shown aid documentation notation step making automatic time part design programming applications notation suggestions made implementation larger goal june smith
language simulation language based programmed algebraic language language internal implementation major differences presented paper programming language attempt present description included sufficient description material familiar algebraic languages june
iteration element recent addition language made iteration structure statement algol statement fortran statement expressions june galler
method data list processing application analysis set subroutines discussed designed aid programming computations lists numbers machine language symbolic assembly commonly performed list operations outlined groups computation power spectral density function discussed class
dynamic variable
extension current line debugging techniques method assembly language debugging greatly tasks process developed implemented program univac research program online user symbolic assembly language number lines point previously program core program evans
extended arithmetic package fields algebraic number theory arithmetic carried degree precision normal hardware capacity machines cases extended arithmetic package comprehensive easy performing arithmetic package coded ibm general problems design extended arithmetic package specific reference made program
applications binary numbers routines binary number form expression set letters decimal number equivalent expressions easily characteristics examples form expression equivalent expression space power
squares analysis small computers problem analyzing data effect experiment discussed step procedure convergence physical constraints functional form calculation make analysis small analysis carried ibm core memory
modeling simulation digital networks simulation digital networks digital effective means analyzing time logical behavior digital network set time dependent time independent boolean transformations transformation describing input output relationship model element network mode simplicity fortran iv programming digital network discussed illustrated simplicity derived common modeling technique applicable sequential digital networks systematic programming approach
procedure oriented language statements facilitate parallel processing statements suggested programmer writing procedure oriented language sections program executed parallel statements serve range parallel operation define parallel path range nested statements effective computing devices capable degree compute compute overlap
syntax specification sufficient table specification algol syntax additional formal table description basic fortran
operating braille capabilities operating designed common features tape printed output executing programs english braille written small machine minimal equipment jobs card handling processing time minimum perform users functions source list produce object execute user program list card input program list punched output provide storage execute program execution object debugging trace control card braille conversion batch output update tape input subroutines included
relative context free grammar number diverse recognition procedures proposed parsing sentences respect context free grammar paper means common device procedure defined obtaining nondeterministic turing machine equivalent context free grammar turing machine chosen make simple description parsing procedures considered attempt made compare recognition procedures defined simple grammars sentences formal comparison made empirical comparison recognition programming languages lisp algol made means program turing machine univac algorithms producing grammars equivalent context free grammar considered increase recognition efficiency investigated
considerations relating purpose fortran standardization fortran standard
performance systems data transmission transfer rate information bits tutorial standard information characteristic systems performance discussed discussion includes pertinent aspects information transfer determination transfer rate information bits errors standard measurement conditions paper presents arrangement characteristics parameters information examples procedures determining rate terms performance characteristic involving information rate expressed conjunction error rate
logarithm complex number boothroyd
computation fourier coefficients c6
algol education automatic programs algol programs presented evaluation student algol programs program random data searching test reliability efficiency integration procedure statement essential properties order programs effectively wirth
secondary key retrieval ibm secondary key retrieval method involves preparation secondary storage lists primary data records search requests satisfied logical operations lists producing complete set addresses primary records relevant request experimental results presented comparative analysis april
editing function language data processing automatic indexing mechanical translation procedures editing required automatic method desired paper discusses economy editing function amount text language processing operations editing editing correction improvement output survey article editing interpretation expansion output processes factor analysis applications processes factor analysis applications evaluation large volume summary reports computers produce april
romberg quadrature modified form romberg quadrature sensitive rounding errors april
numerical solution point boundary problem linear ordinary differential equations method numerical solution point boundary problem linear ordinary differential equations developed method requires runge kutta interval consideration solution linear equations april day
code structures protection manipulation variable length items corrigendum april
fortran ii chaining april
cobol subroutines fortran main programs april
numerical method partial derivatives determination recent article communications acm suggested technique machine evaluation partial derivatives function analytical form solving linear boundary problems partial derivatives formed evaluated numerically method appears programming equations april bellman
conditional base number encoding sequences characters procedure efficient encoding sequences characters selection rules procedure shown unique integer sequence generate compact set values april brown
numerical integration differential difference equation time systems variable time present common variable flow rates common variable present extensive knowledge exists effects variable shown method reducing differential difference equations ordinary differential equations studied numerically ease subsequent study deal situations multiple dependent solution present april bellman
data input question answer data input scheme time sharing paper format statements determine input user required values time user input process errors standard data editing values input april
fortran subroutines cobol main programs proper cobol coding techniques accounting differences storage allocation library routines languages write fortran iv subroutines called cobol main programs technique enables programmer advantage properties language minimizing april
matrix inversion f1 april
bessel function set integer orders april
eigenvalues eigenvectors real symmetric matrix qr method f2 april
eigenvalues real symmetric matrix qr method f2 april
vector coefficients april
list processor presented paper teaching language employed university constructed serve means introducing simulation list processing concepts advantages discussed examples april
proposed revised american standard code information interchange april
mode control procedures data communication american standard code information interchange tutorial paper considerations task group x3 area mode data communication control philosophy paper level control earlier tutorial paper control procedures data communications task group document x3 present paper solutions problems basic ascii communication control characters outlined previous paper mentioned cover additional control problems handling material line data ascii codes means systems providing complete character cover concepts normal character structure rate conjunction earlier tutorial paper paper expected lead proposal data communication control procedures american code information interchange april
tabular input data george
correct method variable precision division paper correct method variable precision division digital computers earlier methods present method form divisor estimate quotient characters results correction estimate obtain exact quotient character method widely applicable division operations variable word length character oriented machines
method properties commonly random number generator analyzed
note precision floating point arithmetic bit numbers recent paper technique double precision floating point arithmetic similar technique developed precision floating point arithmetic purpose note describe technique multiplication division algorithms addition obtained modification paper
pert time calculations topological ordering simplified technique presented pert time calculations topological ordering event assigned unique memory location activity represented link link defined memory location address memory location time information activity carried link typical activities bit cell bit cells forward calculation expected time activity backward calculation time activity calculations progress represented core
e4
e4
adaptive numerical integration simpson rule d1 pike
solutions equation a1
function minimization e4
algol conventions
parallel data transmission proposed american
correspondence algol lambda notation part ii
rapid turnaround multi programming paper basic features characteristics control multi programming rapid turnaround time
internal structure fortran translator fortran translator source program written fortran language object program written language paper outline internal structure translator emphasis compilation expressions input output lists variables
class languages discussed paper concept fully nested language means designing languages completely free ambiguities suggestions algol fully nested language
controlled program line data analysis paper describes technique designed ease data processing primarily concerned significance data handled time master programming language essential aided commands user required learn vocabulary language vocabulary displayed means drive scope vocabulary elements required light small set rules applied result light user generates correct commands learn grammar program user language method communicating program makes restrictions natural program successfully ten
mathematical model mechanical part description flexibility mathematical model takes advantage common information requirements aided engineering drawing numerical control tape generation physical characteristic computation control man machine communication requirements improved results conventional engineering design processes english input language designers describe part output desired approach mathematical model consists group surface defining equations created modular convert mathematical model instructions automatic machines numerical controlled machine tools physical part characteristics center computed dynamic analysis work proposed presented experiments discussed
user oriented language developed makes fast preparation management reports computational complexity format variety costs sufficiently low reports prepared requires initial preparation large data data elementary form special languages permits selective extraction data subset efficient processing computational sequence flexible presentation results tabular graphical form matrix algebra fundamental vehicle manipulation computation
rapid braille technique ibm machines
efficient
recursion iteration
construction nonlinear programming test problems
organization symbol tables efficient symbol table organization important feature design compiler construction algol compiler primary consideration symbol table design recognition words rapid general features technique
service administration manual years procedure satisfactory time manual fully automated january program written format fortran ibm program maintaining created written programming language minimum amount required operating united states records detailed records material created received records total received period time reported created
bessel functions kind gautschi
poisson polynomials
iteration f4
inverse permutation g6
wirth
correspondence algol lambda notation part paper describes semantics algol correspondence expressions algol expressions modified form notation model languages compute behavior based functional application functional abstraction language features model abstract object language algol algol features small number structural rules correspondence part paper formal description abstract compiler abstract language presented functional notation application abstraction
answering english questions survey experimental english language question answering systems programmed operating reviewed systems range machine programs make sentences pictures systems english logical systems list structured data based graphic data based text based principles methods operations detailed discussed concluded data base question answer initial research early phase difficult important research questions general purpose language processors concerned measuring ambiguities formal languages searching large tree structures january
remote line real time diagnosis presented paper report hardware software configuration function remote online real time digital diagnosis sort lead satisfactory solution problem automatic diagnosis current attempts authors extend diagnostic capabilities present concerned increasing adaptive development dimensional pattern analysis analysis parallel diagnostic interaction study possibility introducing major tree decisions early diagnostic process january
boundary networks feasible procedure determining total partial inclusion points lines respect set general polygonal domains partition plane bounded region scheme representation domains based scheme evaluating inclusion relations detail method employs levels selection criteria purpose reducing number accesses auxiliary storage devices amount boundary data processing required january
decision tables programming decision table tabular form decision logic decision tables inherent advantages technique illustrated advantages enables program directly decision table technique based creation binary image limited entry decision table memory binary image set input conditions created data image scan decision table image proper action advantages programming point view amount memory reduced programming simplified documentation january
remarks reducing truncation errors january
simulation boolean functions decimal january
automated plotting flow small january
code structures protection manipulation variable length items items made variable number characters number bits control information partition symbols mark errors identification control characters lead methods symbols bit code assignment characters fixed word length computers error detection variable length item manipulation shown flexibility arithmetic operations january
subroutine assembly description assembly requires pass table information subroutine library january
reducing truncation errors large number quantities numerical integration sum larger individual results truncation error error eliminated noted recent article simpler slightly flexible presented deals case january
algebra operators theory program written generate tables formulas operators theory operators expressed polynomials variables simple differential operator arbitrary integer polynomials generated recurrence scheme program coded fortran simple array manipulation techniques perform algebraic operations formulas operators produced program january
character set character recognition proposed american january
programming language january
euler generalization algol formal definition december wirth
additional comments problem concurrent control december knuth
development algol december wirth hoare
slow philosophy monitor slow output devices presented december
levels systems building current systems levels control command communication problems continued structure questions effects usefulness future systems regard time sharing parallel programming systems learn questions general problem discussed december
problem algorithms december
d1 december
statistical computations based models based machine statistical model related symbolic specifications efficient method performing calculations statistical models balanced complete nature presented mixed random analysis variance models considered procedure obtaining variance components calculated statistics model terms included december
tensor calculations formac program written capable calculating quantities interest tensor calculus code symbols calculated basic orthogonal coordinate systems december
application process obtain rational approximation modified bessel functions established polynomials approximating functions rational results show efficient obtain approximations small error polynomial case approximation directly series development paper limitations applicability extensions case approximations rational present numerical results december
general time systems error program evaluation propagation variance technique time systems initial condition parameter errors involves determination dependent partial derivative matrices requirement separate programs investigation program utilization differentiation technique automatically determines required matrices specific equations subroutine form execution time programs development extremely general programs december
program programs produces flowcharts programs written programming language describe syntax control statements language purpose resultant object flowchart programs language examples snobol flowcharts scope existing languages define language structured manner feature desirable comments program approach permits documentation descriptive remarks inclusion coding details december
computing capabilities universities report author universities descriptions computing activities present equipment capabilities large scale institutions complex time shared systems future author state principal factors organization academic procedures university government relationship organization computing facility professional interchange knowledge effects constraints december
analyzer context free languages relative efficiency context free grammar standard form grammar constructed generates languages generated rules form intermediate symbols terminal symbol analyzer standard form grammar language context free grammar equivalent standard form grammar structural descriptions assigned sentence analyzer structural descriptions assigned sentence original context free grammar derived section due standard form grammar rules standard form additional information describing derivation original context free grammar technique performing transformation effectively section analyzer parsing arbitrary context free languages compared parsing algorithms selective top bottom similar error parse analyzer extension normal grammars comparison based criteria efficiency core storage requirements programs processing time november
automatic error bounds real zeros rational functions procedure implementing interval arithmetic version newton method proposed procedure require starting interval zeros rational function method automatically bounds roundoff error november
automatic integration function parameter efficient methods automatic numerical integration romberg integration adaptive simpson integration form parameter shown romberg method efficient fortran program shows achieve greater efficiency november
techniques automatic control linear programming technical note numerical steps simplex method linear programming reviewed needed numerical procedure defined objective criteria numerical steps method calculation november
conversion decision tables programs rule mark techniques rule mask technique method converting limited entry decision tables programs recent discussion suggest technique constructing networks trees technique presented produce object programs longer run time paper modification technique discussed takes account rule frequencies relative times evaluating conditions improve object program run time november
regular coulomb wave functions november gautschi
d1 november
examination scheduling november williams
syntax macros extended translation translation approach extended syntax semantics high level base language formalism called syntax macro syntax macros define string transformations based syntactic elements base language types macros discussed examples conditional generation macros based alternatives scan november
data applied information storage retrieval applications manipulation data strings complex processing function information storage retrieval applications data string manipulation discussed context interpretive processing environment controlled sequence derived job assumed expressed user oriented source language data string structured data environment data bank explicitly related format format library processing data string manipulation developed generalized data concept results implementation part data internal processing functions data strings format declarations input output november
description systems data transmission tutorial october
rectangular row punched proposed american standard october
code extension ascii tutorial american standard code information interchange ascii number control characters principle code extension representation information directly represented means characters code manner characters previously completely paper presents set code extension applications suggests set application code extension characters drawn code extension concepts graphic substitution syntactic representation similar requirements topics concerned code extension linked discussion code applications material paper applicable principle proposed bit code information interchange october
general method systematic interval computation numerical integration initial problems procedure computing monitoring step size starting order numerical integration method solve initial problem procedure estimate truncation error step size october
mathematical time equations form arise number scientific contexts authors point interesting properties solution properties obtained means numerical solution october bellman
mathematics formac formac formula manipulation compiler programming powerful tool performing mathematical analysis extension fortran iv permits perform algebraic computations arise fields areas successfully differentiation complicated expressions expansion power series solution simultaneous equations coefficients nonlinear maximum estimation tensor analysis generation coefficients equations motion types analysis solution specific practical problems physics engineering statistics discussed paper addition usage specific problem solutions formac analysis phase production programming applications presented october
simulation discussion technique comparison languages purpose paper present comparison simulation languages involved comparing software packages digital computers discussed part obvious users digital computers languages write substantial costs occur training implementation time language simulation languages developed comparisons existing languages designers users part simulation simulation languages computational characteristics simulation discussed special attention continuous discrete change models part iii presents detailed comparison simulation languages packages characteristics summarized series tables implications analysis designers languages users developed paper packages simulation features general purpose packages analysis suggests ways current future simulation languages packages improved october
character structure character sense parallel bit data communication ascii proposed american standard september
systematic generation circuits combinatorial matrix directed paper describes program generates circuits specific application made problem september
half dimensional space iterative procedure determining half dimensional space method cyclic jacobi procedure elementary plane obtain half matrix numerical examples september
linear equations exact solutions f4 september boothroyd
logarithm gamma function s14 september pike hill
direct search e4 september bell pike
gamma function gamma function range gamma function real argument gamma function logarithm gamma function algorithms s14 s14 s14 s14 s14 september pike hill
evaluation determinant determinant evaluation algorithms september
function minimization e4 september
modified method september
pseudo random numbers g5 september
pseudo random numbers g5 september hill pike
final solution algol related languages problem consists class potential ambiguities algol conditional statements basic form boolean expressions basic statements difficulty existing solutions problem statements define closed statement open statement statement closed statement open closed conditional statements defined syntax equations case closed statement shown syntax equations change statement types required syntax equations lead ambiguity restriction september
algol based simulation language paper introduction programming language designed provide systems concepts facilitate description discrete event systems description source language simulation program extension algol important concepts parallel processing september
impact computers undergraduate mathematics curriculum computers permit application mathematical ideas requiring computation science technology extremely significant understanding current society student interest development utilized yield understanding mathematical concepts ideas programming logical structure introduced fields computers present paper suggests portion undergraduate mathematical curriculum preparation mathematics professional modified include extensions computers early introduction programming desirable permit automatic computation illustrate mathematical concepts calculus equation stage introduction numerical analysis added current curriculum addition providing computing techniques permit sophisticated utilization advanced mathematical ideas complex variables transform september
desired impact undergraduate mathematics relating discussed author examines projections demand united states comments briefly factors professional activities applied years discusses terms information undergraduate training september
implications digital education mathematical sciences digital definition interesting mathematics importance applied logic human existence logical result longer terms single discipline mathematics terms complex mathematical sciences september
mathematics undergraduate mathematical requirements undergraduate program science subject computing curriculum committee requirements essentially mathematical content physical sciences undergraduate programs committee requirements student mathematical background wide variety courses scientific committee develop solid scientific approach science september
technology based information items literature period technology reviewed initial planning organization educational aspects technology machine development progress major specific machines aid due aid made machines present applications control production processes data processing science operation programming attempt made concepts linear programming ordinary capability machines binary nature point september
symbolic polynomials variables finding symbolic factors multi polynomial integer coefficients presented extension technique proof prime polynomial found finite number steps consists single variable polynomial method introducing variables interpolation techniques implementing examples discussed sufficient power efficiently online symbolic mathematics august
solution systems polynomial equations elimination elimination procedure williams coded lisp formac solving systems polynomial equations found method effective case small systems yields solutions initial estimates method appears solution large systems equation due growth intermediate equations arise coefficients comparison made difficulties found problems numerical mathematics symbolic integration simplification august
automatic mathematical analysis symbolic translation procedure numerically solving systems ordinary differential equation shown generate symbolic solutions procedure based finite taylor series expansion includes estimate error final result program equations generates dependent variables determined numeric parameters original equations carried automatically final exact parameters problem solution easily displayed august
programmer description bell telephone low linked list language programming language list structure facilities list processors lisp snobol permits user machine code order write faster running programs storage efficiently variety linked data structures august
convert programming language applicable problems transformation rules patterns skeleton series pairs pattern found expression conditions match code subexpressions identified skeleton primitive patterns primitive principle complicated patterns advantages language transformation rules lists arrays easily strings patterns defined programs stated august
experiments finite algebra medium scale programming written ibm manipulate objects algebra finite groups maps sets maps subsets sets subsets constant integers values designed operate time sharing environment serve aid undergraduate student algebra working subset august
experience formac design design implementation mathematical expression manipulation algorithms discussed examples provided formac differentiation algorithms basic formac utility routine experiment extraction structure expression avoid intermediate expression order minimize core storage requirements details formac implementation presented attempt made principles ideas general design algorithms manipulating mathematical expressions august
polynomial manipulation ibm program formal manipulation polynomials number variables integral coefficients size formal operations performed sums differences products derivatives greater common based iii list processing compared lisp slip systems subroutines arithmetic large integers independently compared including choice forms polynomials polynomial greatest common divisor calculation mentioned included illustrate august collins
computation algebraic properties elementary digital large number calculations high elementary physics manipulation complicated algebraic expressions tensor matrix quantities calculations complete operations involved straightforward rules paper program developed lisp solving problems manner problems encountered outlined representation discussed present human work takes ibm limitations present future outlined august
implementation language symbol manipulation description implementation technique replacement rule programming language scan application applicable members family string transformation languages design language august
survey formula manipulation field formula manipulation attention specific capabilities differentiation integration capabilities simplification displays input output editing precision arithmetic general systems batch online finally programs solve specific applications discussed august
acm symbolic algebraic manipulation acm symbolic algebraic manipulation people programming languages designed manipulation algebraic formulas symbol strings applications algorithms implementation papers presented discussion future directions interest groups acm special interest committee symbolic algebraic manipulation program committee made floyd editor august
data solution multivariate type problems social sciences approach outlined solution type multivariate problem found social sciences approach logical statistical criterion variables deterministic model developed variables analysis eliminated criteria variable termination searching process derived information theory july
top bottom recognition left recursion procedure obtaining structural descriptions context free grammar performing recognition strongly equivalent left recursion effect allowing strings rules discussed july
free text inputs utility routines simple techniques frequently produce program free text inputs techniques discussed related general tape manipulation routine july
calculation eigenvalues problems systems ordinary differential equations considered computationally technique successive approximation scheme related newton method july bellman
partial step integration partial step integration equation derived method integration differential equations method obtaining functional values points intermediate integration points yields accuracy comparable integration require storing additional information interpolation methods july
method finding values function defined ordered sets positive integers minimum increasing function defined partially ordered set assumed set minimal points efficient method finding functional values functions defined ordered pairs positive integers method easily extended include functions defined ordered included fortran program written implement procedure important case july
computational aspects multiple covariance analysis structure computational procedure analysis multiple covariance statistics discussed reference analysis variance special operator calculus developed programming analysis variance experiments extended cover analysis covariance extension accomplished connection analysis covariance analysis variance introducing operator results illustrated numerical analysis covariance basic computations shown carried analysis variance program july
matrix integer arithmetic f1 july
solution simultaneous linear equations f4 july
interval ratio july hill pike
drum scheme prime function drum operating real time perform accesses usual means increasing capacity engineering hardware improvements paper problem changing drum manner operates drum functional definition simple design scheme introduced increases rate defined shown perform job employing fewer suggested design scheme specific method underlying general applicability question drum scheme deal standard efficiency developed light real time drum scheme manner permits analyzed problem queueing theory drum scheme efficient application analysis drum scheme specific methods underlying general applicability july
digital line memory state university designed constructed medium speed serial digital lines memory design objectives special research project design educational machine easily hardware basic research systems design arrangement information memory simple interface arithmetic unit results effective latency time associative memory arithmetic unit command structure similar large parallel machines arithmetic control registers hardware development concept easy modification console effective man machine interaction low cost july jr
statistics time sharing systems optimization time shared performance requires description stochastic processes user inputs program activity paper statistical description user input process general purpose time sharing input process assumed defined time distribution data obtained common assumption times independent data approximation usual assumption exponential distribution time satisfactory approximation data obtained distribution july
comparison algorithms computation means standard correlation coefficients algorithms computation basic statistics compared performance generated test data statistics calculated standard deviation correlation coefficient statistic included usual computing formulas correction due error term recursive computation current statistic usual computing formulas evaluated double precision large errors noted calculation usual computing formulas reliable technique correction initial estimate error term eliminate making data suggested initial estimate obtained subset data july
information concept large point major accounting applications automated sophisticated usage data processing equipment availability equipment suited real time direct access processing development central file data base approach information information purpose providing real time individual account providing complex combinations information management kinds processing common store data contained direct access central file data base includes facilitate cross account information relationships bank introducing information concept approach account cross file conversion generally interface applications existing bank july head
technology education educational technology aspects technology generation ideas potential actual time scale social response potential technological change object paper present potential educational technology questions modes social response july
row punched card code information interchange proposed american standard june
automatic derivation decomposition long complex english sentences sentences suggested automatic retrieval natural language messages step authors general program longer sentences analyzed analysis program basic idea subject object program paper designed operate tree structure output analyzer produced authors quality achieved open improving performance automatic message retrieval systems practical man machine systems human monitors syntactic interpretation sentence june jr
fortran technique input report generators typical report generators production standard forms magnetic tape file extraction sets information suitable involves forms design method information extraction involving calculation suitable fortran format statements problem june
scale ibm cost functions models analyzed examinations instruction times program typical instruction mix comparisons made data developed law applicable data scale present computing equipment june jr
examination scheduling june williams
chebyshev quadrature d1 june
uniform pseudorandom number generator pseudorandom number generator discussed prime capacity primitive root prime generator usual statistical tests addition significant bits random significant bits property generators june
development algol programming language similar algol incorporating large number improvements based years experience language detail part consists introduction language summary made algol discussion part ii definition proposed language part iii describes set proposed standard procedures language including facilities input output june wirth hoare
paper tape proposed american standard
simple computing generalized inverse matrix generalized inverse matrix important analysis extension concept inverse matrices applications numerical analysis widely existing algorithms complicated require considerable storage space simple extension found conventional method singular matrices generalized inverse effort additional storage requirements generalized inverse matrix including special case singular case case ordinary inverse case yields ordinary squares transformation matrix advantage avoiding loss significance results product explicitly
automatic analysis electronic digital circuits list processing mapping diagrams digital circuits list structures list processing program written control data mapping automatically circuit analysis
flow diagrams turing machines languages rules part paper flow diagrams introduced represent set finite number base diagrams true level due suitable extension set basic defined normalization methods flow diagrams base diagrams part paper method applied theory turing machines turing machine provided half tape similar machine essentially job working tape obtained squares machine family introduced generated composition iteration machines family proper family turing machines
simulation policy study policies large specialized objective determine policies rates maintaining full types policies examined based rates rates constant fixed independent rates type policy produced stable simulated results practice improvements realized smith jr
simulation scanning field increasing importance diagnosis scan dimensional pattern made areas increased source activity represented scan areas increased density study output characteristics program written pdp auxiliary disk storage ray display past present research output shown flexibility important structure program simulation output limited
iii aid management iii iii online digital assist monitoring jr
matrix reduction method generation school application method problem matrix reduction needed gotlieb method timetable generation method suited hand calculation devices improve efficiency basic discussed
multiple precision floating point conversion decimal binary decimal binary binary decimal floating point conversion performed table positive integer converting base base table coefficient polynomial approximation converting base base tables large storage region case precision conversion paper shows single small table floating point conversion decimal binary precision
storage mapping function data structures basic data structures reviewed efficient presented constructing storage mapping function structure structure definition
input output devices fortran systems fortran readily modified handle input output basis standard providing character handling subroutine suited medium called output statement type unit number method control output information digital graph plotter
note linear programming design combinatorial problem linear programming models size actual data magnetic tape disk fast increasing effort made design efficient algorithms paper support effort find characteristics column found number transfer data tape core memory considered simplification problem general generating function probability distribution generating function number found asymptotic formulas result paper results applied write efficient routines search table formulas provide means calculating case
monte carlo students classes technique random choice illustrated application problem students fixed schedule courses technique reduce eliminate difficulties result section closed students requiring effectiveness automatic scheduling loss students
design simulation experiments systems paper provide background information existing literature experimental design techniques applicable design simulation experiments systems major emphasis analysis variance techniques techniques data analysis considered multiple procedures sequential sampling spectral analysis paper specific experimental design problems techniques solving experimental design problems problem stochastic convergence problem factor selection problem response problem
interchange blocks data
mutual primal dual method
method zeros complex functions method computing index number developed applied problem finding zeros functions plane plane april jr
curve fitting process process fitting curve approximate data problem programmer defined approach defined written major portion process techniques developed empirical dependent information actual data points april
starting approximations square root calculation ibm starting approximations square root calculation newton method presented form facilitate ibm square root routines approximations include range interval primary interest ibm april
methods numerical integration applied function study made determine methods numerical integration require computation time amount truncation error applied ordinary differential equations function recent methods due compared runge kutta kutta methods step methods due found slightly superior method found great advantage application problem april
recorded magnetic tape information interchange proposed american standard april
method finding squares estimate intersection point space moving common point magnetic field measurements measurement errors general method squares manner april
generating reduction formulas matrix elements algol procedure automatically generating formulas matrix elements solution equation systems april
statistics obvious aid calculation offered change curricula mathematics statistics physics engineering courses obvious aids teaching subject student technical conceptual understanding statistics number years university reported april
chebyshev quadrature d1 april
quadrature d1 april
romberg quadrature d1 april
derivatives s22 april gautschi
simultaneous polynomial roots real simple april
runge kutta integration april thacher jr
kutta april
nonrecursive method syntax specification regular expression notation describing algebraic language syntax algol paper fortran ii program elimination similar gaussian elimination linear systems algebraic equations applied smaller languages including algol hand calculation result application algol revised algol syntax completely nonrecursive terms context free portion concerned description ways previous recursive description suggested paper includes results machine program include simplification april iii
simple user oriented compiler source language programming automatic test equipment difficulty language increases number oriented conventions simple language considers user background part problem effective source language powerful capabilities language paper write programs test electronic equipment testing process complex ideas redundancy highly syntax oriented language simple direct language problem users language expected programming significant programming training oriented user essential create language familiar engineering statements programming oriented conventions complicated task april
procedure describing language typewriter description text compiling language processing language developed basis software package typewriter language write procedures storing character string typewriter string string time procedure text string language based extension generalization character strings programming concept macro ability store definitions procedures capabilities language extended deal character strings integers boolean vector variables
storage retrieval aspects meaning directed graph structures experimental lisp make conceptual dictionary dictionary english word syntactic information material references contexts define words relations class inclusion active actions material resulting structure powerful vehicle research logic question answering examples methods information answering simple english questions important lisp list processing languages suited producing complex associative structures language processing large scale auxiliary memory continuous extension core memory
data manipulation programming problems automatic information retrieval automatic information retrieval programs require manipulation variety data structures including linear text sparse matrices tree list structures main data performed automatic information systems briefly reviewed variety data representations describe structured information examined characteristics processing languages outlined light procedures requiring implementation advantages programming languages retrieval application examined suggestions made design programming facilities aid information retrieval
online programming transition made line online programming number working conditions noted environment make processes related producing checking programs main programming language provide facility online user programming language paper online environment effect programming discussed schwartz
requirements real time languages real time languages requirements programming languages special nature applications environment object programs executed environment compiled language extensions developments field progress made special compiling executing problems solved
evolution meta assembly program generalized called meta meta defined factors evolution presented meta made function assembly program finally meta compiler design discussed
discussion summary operating systems
multilevel operating systems basic software computers built established standard operating systems implies applications large complex time operate top standard large applications require supervisory monitors handle problems similar operating systems level fourth level required desirable concept multilevel systems similar proper division levels greater efficiency logical complexity capability
extensible machines characteristics extensible machines facility providing control program program program data linkage address connection paper remarks program program program data linkage authors previous paper concepts finally trace employment linkage mechanisms levels programming languages
algol compiler construction relation operating algol translator prepared integrated operating assembly features permit execution debugging information chain feature written map fortran algol called algol main program addition procedures coded map included algol program assembly loading time compilation time total time satisfactory user ease facility fully
program translation viewed general data processing problem efficiency effectiveness compiler increased means compiler substantial logical structure reliability data processing techniques compiler based fixed conventions efficiency reliability conventions structure parts program economy features reliability naur
discussion summary graphical languages
graphical variable syntax man machine interaction fields greatly future interactive graphical languages provide variety display scope communication procedures graphic service functions generalized graphical language translator developed aid definition graphical languages
syntax directed interpretation classes pictures descriptive scheme classes pictures based techniques parallel processing algorithms proposed author years work pictures parallel processing written ibm cdc paper descriptive models specific application pictures description generated phase embedded larger program explained means specific partial grammar english letters generated grammar parallel processing mentioned earlier
programming languages family computing languages intended differences application area framework framework rules user names conventions functional relationships framework design specific language independent parts choice written programs generally physical representation choice abstract numbers character strings lists functional relations language expressions statements includes nonprocedural functional class users single instruction important properties make conventional hand side expressions easy construct
structure programming languages identified major components programming language elementary program statement mechanisms linking elementary statements means program obtain data inputs alternative forms components compared evaluated examples frequently list processing languages illustrate forms elementary program statements form commands requirements implicit specifications command statement commands action requirement describes effect achieved actions implicit specification similar requirement programmer actions achieve desired effect subroutines explicitly execute call function composition explicitly called subroutines generally require special linkage conventions execute subroutine call basic instruction programming language function composition convenient alternative explicit call principal ways inputs routines data data means variables functions names entry points data structures error contexts author discusses advantages factors choice form component language evolution programming languages permit convenient ways structuring programs organizing systems data
programming semantics multiprogrammed computations semantics defined number meta instructions perform operation essential writing programs multiprogrammed systems meta instructions parallel processing protection separate computations program debugging sharing users memory segments computing objects names structured language assembly language advanced algebraic language
description high capacity fast turnaround university computing center operating univac case reviewed interest low turnaround times achieved high achieved lack operating turnaround times job volume reported
stability fourth order runge kutta method solution systems differential equations problem region stability fourth order runge kutta method solution systems differential equations studied region characterized means linear transformation closed form paper region determined electronic digital
tests probabilistic models propagation roundoff errors computation generally assumed effect roundoff errors sense statistical purpose paper give precise descriptions probabilistic models roundoff error describe series experiments testing models concluded models general good test techniques experiment types special arithmetic
master file business applications sequential magnetic tape random access storage techniques process small number master file situations prove avoid master file updating run producing master file activity head
control procedures data communication progress report committee american standards task groups x3 define functional control requirements characteristics operation digital data generating systems communication effort primarily directed systems employing american standard code information interchange ascii paper represents progress report work group proposal national standardization field control procedures describes work task group work presented detail work presented earlier papers control procedures data communication task group document x3 mode control procedures data communication task group document x3 december comm acm control procedures data communications task group document x3 summary form concepts principles organization standardization earlier papers working papers organization
euler generalization algol formal definition part ii wirth
exponential curve fit e2
exponential curve fit e2
computation chebyshev series coefficients c6 smith
graph plotter
programming picture processing debugging picture processing measuring depends input memory types applications authors analysis linear graphs main concept collection pointers family
comparison fortran language implementation computers feature feature comparison made implementations fortran iv representing table constructed showing feature implementation items added fortran ii shown
language describing functions systems design exact function desired suggested oriented language purpose standard programming languages description systems discussed algol suitable describing systems introduced descriptions simulation automatic design addition communicating specifications
structure programming languages paper major components programming language identified elementary program statement mechanisms linking elementary statements means program obtain data inputs alternative forms components compared evaluated examples frequently list processing languages illustrate forms advantages factors choice form component language discussed paper programming languages permit convenient ways structuring programs organizing systems data
machine paper description model programming directed programming language library storing user items rules programs written language items library share common parts made mechanical detection common parts patterns library items user solve problems relationships behavior machine human behavior
program study language communication man machine program operating time sharing makes kinds natural language man input sentences analyzed basis decomposition rules key words input text generated rules selected decomposition rules fundamental technical problems concerned identification key words minimal context choice transformations generation key words editing capability discussion issues relevant approach future developments paper january
programming decision tables fortran cobol algol simple based approach programming decision tables fortran cobol developed presented inputs standard form defined paper programming decision table fortran statements cobol statements compute cobol processor shown method applicable states table conditions shown multi state conditions decision tables simplify programming method outlined advantage combinations conditions considered shown suggested procedure easily implemented algol january
data documentation decision tables business data processing systems define document data files programs decision rules represents changing information content continuous interaction tabular description makes objective cost time systems analyzed programs prepared modified show tabular techniques make detailed test provided january fisher
paper tape information interchange proposed american standard january
euler generalization algol formal definition part method defining programming languages developed relationship structure meaning structure language defined phrase structure syntax meaning terms effects execution sequence interpretation rules fixed set variables called environment exists correspondence syntactic rules interpretation rules determined sequence syntactic parse individual interpretation rules explained terms elementary obvious algorithmic notation method evaluating text provided classes languages proved generalization algol full detail demonstrate concepts block structure procedures parameters defined method january wirth
january thacher jr
generation derived test matrix f1 january boothroyd
complete elliptic integral kind january
solution transcendental equations series developed solution equation power series power series root illustrated equation january thacher jr
formal semantics languages application compiler compiler semantic meta language developed representing statements large class languages meta language basis construction efficient compiler compiler discussion meta language based complete translator small language presented january
normalization requirement divisor correct methods paper presents analysis normalization requirement divisor correct method analysis made subject condition correction required obtain true quotient character estimate division precision segment partial single precision divisor division precision basic division found normalization requirement smaller range provided character leading character divisor normalization eliminated proper higher precision segments basic division considered possibility normalization increase number quotient estimate precision basic division shown scheme small december
technique programs written algol technique analysis computation process terms original source program december
curve fit revised e2 december boothroyd
curve fit e2 december boothroyd
eigenvectors 2n 2n matrix eigenvalues 2n 2n matrix obtained smaller matrices order easily constructed obtain eigenvectors 2n 2n matrix eigenvectors smaller matrices december
online editor online interactive test editing detail remarks theoretical experimental form emphasis providing maximum power user features ability handle text content searching facility character character editing operations editor programmed limited extent december
fortran case study programs vehicle model written fortran iv compared comparison made terms basic program design decisions storage requirements time ease making program primary design considerations center choice model variables model changing events model testing fortran program basic design problems representation time allocation storage organization input data comparison designed programs shows program storage time requires fewer program model december
algorithms finding fundamental set cycles linear graph matrix graph presented paper spanning tree constructs set fundamental cycles presented ratio number nodes requires storage graphs large number nodes edges storage limited superior graphs small machine storage large superior timing estimates storage requirements methods presented december gotlieb
organization resource allocation paper resource management concepts process facility event processor attempt made give suggestions policy resource allocation basic framework provided solutions resource management problems paper divided tutorial presentation description primitives small collection examples primitives december
monitor time sharing online laboratory online monitor developed primarily support numerical applications retrieval large files means user retrieval application monitor designed work small ibm techniques resource allocation important core storage computational facilities input output feature event driven driven program segments called execution remote run back time december
multiprogramming environment online data analysis experimental analysis large data derived scientific experiments architecture implementation based objectives characteristics general data analysis scheme early applications oriented investigation data obtained research problems encountered chosen approach discussed december
magnetic tape information interchange proposed usa standard november
recorded magnetic tape information interchange proposed usa standard november
finding solution functional equations november
taylor series method minimizing sum squares solving systems nonlinear equations november
solution simultaneous linear equations november brown
permutation g6 november
expected term retrieval systems file procedure based expected proposed term retrieval systems expected probability distribution derived function terms coefficient distributions values statistic parameters typical information retrieval november
inference execution data retrieval paper presents project concerned computers logical analysis large data called relational data file developed purpose relational data file briefly detailed problems implementation discussed november
automatic data compression information noted recent years makes essential storage requirements information minimum fully automatic rapid part information greatly reduce slow external storage requirements increase rate information transmission paper automatically compressed information item item basis required component separately specific tasks discussed automatic compression numerical data automatic compression information compression information stored tape november
methods analyzing data simulation experiments paper addresses problem analyzing data generated simulations economic systems operation represented single channel queueing model total expected period selecting operating strategy allocation inputs total cost results simulated activity test multiple comparison methods multiple method illustrate compare evaluate techniques paper position technique analysis possibly chosen expression experimental objective test tests multiple comparison methods differences multiple methods directly identify november
experimental model problem performance systems general technique ease problem simulation paper reports applicability technique paper describes experimental model hardware software environment measures performance produced model statistics relating turnaround time hardware utilization software utilization queueing processes model consists statements auxiliary programs job generator automatically properties jobs simulated november
george general purpose time sharing operating operating run wide variety configurations handle large number online console users time running line background jobs oriented mode batch processing supervisor user multics simultaneously depending online users line jobs common command language includes multilevel device independent file store november
square root complex number october
multi dimensional partition generator a1 october mckay
quadrature d1 october
time sharing cdc time sharing embedded standard batch processing cdc general purpose file based providing facilities file input manipulation editing compilation conversational execution simple scheme extension machine memory bound register attempt made code segmentation paging implementation time approximately man years code written fortran october schwartz
criterion polynomial root finding searching root polynomial generally difficult number approximation root paper presented iteration process basis calculated bounds roundoff error occurs evaluating polynomial criterion tested examples found serve satisfactory means complex number real polynomial october
computing fast fourier transform proposed fast computing complex fourier transform shown major time savings compute large transforms digital power computing time proportional log2 major improvement methods computing time proportional paper fast fourier transform briefly reviewed fast difference equation methods accurately computing needed function values problem computing large fourier transform virtual memory considered solution proposed method compute complex fourier transforms size words core storage factor maximum radix transform size fixed allocation amount core storage method compute large mixed radix transforms computing fast fourier transform fixed point arithmetic october singleton
multiprogramming page demand strategy model multiprogramming page demand strategy developed analysis model performance measured average usage cpu user programs typical interactive time sharing environment effect hardware modifications analyzed parameter readily calculated hardware characteristics program statistics proposed effect multiprogramming october smith
grammar base question answering procedure subject paper procedure automatic retrieval segments stored information explicitly represented questions natural language sentences procedure makes sentence recognition device class grammars correctly sentences natural language make recognition device sort data fully set sentences natural language set generated grammar based rules grammar sentence evaluate sentences questions normal situation recognition function case question drawn set sentences data correctly terms grammar set sentences sentence recognition procedure retrieving information recognition function represents information october
drawn letters detailed descriptions letters numbers basic vectors general form easily drawn variety computers ray include upper lower case letters mathematical upper lower case letters design principal paper october
decomposition programming analysis matrix problem analyzed order compare primal primal dual decomposition algorithms analysis relative performance algorithms performance compared standard primal simplex solution decomposition october bell
macro processor general purpose macro processor called implemented pdp computers intended tool users extend existing programming language incorporating statements syntactic forms notation complete user oriented language built relative ease october brown
algol paper lists ambiguities language algol revised algol report october knuth
hardware software october
model university executive mathematical model executive parameters aid extensive data operation assumptions made results model actual results model study effects executive compilers applications model discussed september
operating design implementation operating detail designed control data large drum backing store intended integration remote console display conventional job stack environment input output slow execution normal job stack work display techniques found development made design decisions performance based operation september
comment index register allocation technique presented reduce enumeration required procedure optimal index register allocation line programs technique based construction link shows step future occurrences index registers determines required register configuration steps program program separate allocation procedure applied independently september
dynamic computation derivatives shown procedure computation derivatives implemented compiler generated complex addition linkage complex arithmetic subroutines evaluation function derivative parallel procedure parts variables complex values derivatives real parts technique simple compute derivatives function programming evaluation explicit formulas derivatives september
prime number generator a1 september
prime number generator a1 september
prime number generator prime number generator a1 a1 a1 september
class scheduling section assignment students classes fixed time schedule students give sections courses objective balanced sections stochastic monte carlo nature results compare assignment september
language modeling simulating dynamic systems general objective language facilitate modeling experimental aspects simulation studies ability represent systems highly interactive processes essential feature nature language role process concept presented means extended september
implementation euler ibm model experimental processing algorithmic language euler implemented microprogramming ibm model read storage unit consists compiler string language interpreter control program written machine language results terms main storage space required compiler interpreter performance obtained role microprogramming dimension processing interpretive code structure content higher level language interpretive language executed efficiently existing hardware september
formulation equations motion tensor notation means area application digital computers numerical data processing stage reducing human formulation types problems tensor calculus language designed facilitate symbolic mathematical computation method digital numeric work symbolic algebraic manipulation differentiation illustrate techniques involved digital derive equations motion point general orthogonal coordinate operation involves formulation terms order differential coefficients good capability numeric work assist formulation process numerical data processing stage problem illustrate advantages mathematical techniques employed program prepared purpose derive equations motion coordinate user results presented coordinate systems september
telephone time sharing general purpose remote access computing employs key keyboard terminals output provided directly telephone terminals conjunction high speed devices compatible extension existing batch processing significant element scheme information single numeric keyboard programmed context eliminate ambiguity transmission september
legal privacy society september
standards august bemer
gamma function arbitrary precision s14 august
parsing decision tables reduction size decision tables accomplished techniques techniques considered paper parsing decision tables regard data structures job hardware job context relationships parsing conventions linkage decision tables august
efficient machine independent procedure garbage collection list structures method registers free list essential part list processing paper past solutions recovery problem reviewed compared presented significant advantages speed storage utilization routine implementing written list language degree machine independence finally application number list structures literature august
comparison batch processing turnaround study programming students programming presented effects turnaround conventional batch processing turnaround times examined items compared number runs computation center program preparation time time debugging time number runs time run run problem results fact points programming problem number runs evidence support batch august smith
compiling algorithms arithmetic expressions paper deals algorithms arithmetic expressions fortran iv compiler algorithms generate object code minimizes frequency storing partial results arithmetic expressions cases august
free storage package fundamental underlying problem sophisticated software systems involving changing data structure dynamic storage allocation flexible problem modeling free storage package compiler systems blocks storage obtained total space hierarchy free storage characteristics blocks size special efficient handling selected sizes control garbage collection sharing physical space routines package perform high level functions automatically access control internal details august
understanding computers development program capable natural language discussed importance context human machine understanding argued level understanding achieved depends purpose understanding part machines august
technique dimensional digital automatic plotter generate dimensional dimensional parallel perspective projections dimensional dimensional space observed projections direct extension dimensional experience fourth dimension obtained technique generalized dimensions applied dimensional august
symmetric polynomials july mckay
permutations g6 july
symmetric group characters a1 july mckay
generation permutations pseudo lexicographic order g6 july smith
permutation generator permutation order generation permutations order g6 g6 g6 g6 july smith
problem july
mutual primal dual method july
function july
method finding paths rule finding generalized applied problem finding path graph graph method july
description basic basic conversion decision tables cobol code contained generator portion generator decision table produces simple cobol conditional statements core storage queueing techniques extensive indexing code generated line time optimization elimination tests conditions decision table language developed cobol users written modular form required cobol july
language independent macro processor macro processor source language features macro facility ability make arbitrary transformations argument strings program computing department university process text compilers july
optimal starting values newton calculation problem obtaining starting values newton calculation digital considered shown uniform approximations provide optimal starting values problem obtaining optimal starting values problem obtaining optimal starting values stated basic results proved table optimal polynomial starting values july
representation symmetric polynomials relations symmetric polynomials light theory symmetric group approach earlier work previously published work generalization root technique determination roots polynomial suggested july mckay
plotting function independent variables method developed constructing approximate plot function independent variables plot similar conventional contour map represent independent variables scale values independent variables added function read values july
implementing phrase structure productions pl method implementing productions context free phrase structure grammar pl procedure structure statements parallel structure notation grammar july
string processing techniques internal organization string processing systems discussed techniques data structures presented evaluated basis creation strings examination strings strings speed operation storage requirements effect paging programmer considered techniques single word linked blocks implementation snobol string processing language ibm july
user oriented time shared online existing data processing laboratory research represents attempt provide research ability directly highly sophisticated digital computing complex direct simple experience present significant design determination interface parameters digital july
simulation time sharing systems development large scale time sharing systems number problems computation center management develop hardware configuration systems software made systems manner suggest assist analysis performance characteristics development comprehensive simulation model assist investigation questions paper resulting model general purpose design study variety time sharing systems assist design development time sharing algorithms techniques efficiency greater applicability model implemented limited fortran subset compatible fortran iv compilers simulation demonstrated study ibm time sharing july
adaptive quadrature procedure random sizes d1 june
normal curve integral s15 june hill
incomplete ratio s14 june pike hill
eigenvalues real symmetric matrix qr method f2 june
eigenvalues eigenvectors real symmetric matrix qr method f2 june
generalized squares fit orthogonal polynomials e2 june
real error function s15 june hill
error function large s15 june hill
error function large s15 june hill
gauss s15 june hill
normal distribution function s15 june hill
procedure normal distribution functions s15 june hill
normal curve integral s15 june hill
generalized generalized case polynomial linear combination polynomials term recursion convergence properties method derived june
storage allocation iterative process method core storage allocation iterative process estimates machine time required method applicable iterative processes input data items chosen needed method input data space made output tables overflow occurs important special cases considered considerable simplification occurs june
pl list processing concepts list processing introduced pl language facilities write pl procedures operate simple complex data list organizations list processing languages deal directly complex data structures perform complete range programming language operations data list structures problems eliminated list processing facilities pl basic concepts list processing philosophy pl language extensions discussed addition detailed list processing examples provided june jr
conversational programming graphical algebraic language online graphical input output console device computational aid user basic facilities graphical numeric input display online line program preparation storage presentation results requires minimum experience instruction growth control language processor oriented statements variable type dimension declarations online situation processor graphical keyboard character character basis programmer choice input symbols correct operation research june
period determination speech procedure determines recognition structure speech speech digital ibm pdp recorded normal level compressed phase manner sequence operations defined speech wave list points error detection correction percent correctly times real time ibm june
model teaching teaching model incorporated operating large model control operating execute functions teaching control order teaching teaching ii written run operating ibm graphic teaching automatically student presented ray display terminal readily student mode programmer mode full resources operating language processors compilers library user programs write execute terminal program written language processed operating include text material programming problems student solve terminal simulation provided implications teaching degree flexibility executive training academic education discussed addition advantages type programming operation considered june
string similarity problem programming determine string characters word considered algorithms evaluated proposed writers author techniques tested collection made students levels methods percent june
simple technique digital division simple method digital division method suitable leading character radix character equal method direct half number arithmetic operations needed iterative method suitable similar june
generating permutations application generates permutations elements previously generated permutation constant index needed starting ordering elements application generate additional permutations successive initial circular ordering objects circular ordering obtained elements circular ordering obtained elements manner applications generate circular circular ordering yields permutations generates permutations jr
enumeration finite problem number formed finite point set considered computationally fundamental results established leading finite computed results interesting side result computational work theoretical error literature represents early application side result usefulness area evans
function
vector stored array boothroyd
squares fit orthogonal polynomials e2
numerical solution polynomial equation
chebyshev quadrature d1
parallel numerical methods solution equations classical iterative procedures numerical solution equations provide stage single approximation root question technique development numerical procedures provide stage approximations solution equation approximations obtained iteration computationally independent making methods interest parallel processing environment convergence information iteration numerical procedures technique procedures parallel processing environment developed measurements statistics reported measurements parallel processing environment environment procedures obtained superior standard algorithms
language problems language fortran algol type fortran formula logic representations fortran subset language user describe problem equation form method solution automatically provided conjunction translation equation form instruction language user solve difficult computational problems solution differential equation requiring knowledge numerical methods subroutine logic essentially operations required fortran programming automated programmer concerned details
multiprogramming monitor small machines combination hardware software monitor designed control wide variety real time input output devices simple hardware provide uniform device machine interface elements graphic input devices interval software user program details input output timing task scheduling parallel processing capability user programs monitor small set meta instruction consists machine language subroutine calls
analysis computing center environment empirical distributions program lengths execution times processing times loading times jobs university computing center environment presented data characteristics users jobs obtain selected empirical conditional distributions time properties statistical measures interesting properties results terms properties studied
experimental comparison time sharing batch processing effectiveness program development compatible time sharing compared ibm batch processing means statistically designed experiment identical set programming problems assigned group programming external systems sequence problem solution programmer problem characteristics design factors experiment data obtained variables programmer time time time considered effectiveness analysis variance techniques employed estimate differences variables differences due design factors eliminated statistical analysis experimental results provided strong evidence important differences experimental design implications
integral s15 april hill pike
coulomb wave functions s22 april
numerical integration function common numerically functions range integration occurs integration formulas simpson fitting polynomial method formulas functions kind accurately orders positions explicit formulas easy automatic shown integral integration carried accuracy integration order discussed formula compared simpson formulas advantage april
scheduling university examinations approach problem scheduling examinations presented principle examination schedule requires minimum number examination student required examinations simultaneously found steps examinations period ways minimum number groups included selected multiple occurrences courses scheduling group period minimal schedule obtained algorithms procedures approximations procedure outlined yield feasible small time results experiments techniques april jr
method solution problems matrices method presented solution problem cost matrix implementation method shows fast efficient application classification problem classical problem detail april galler
scheduling project networks basic concepts terminology project developed critical path incorporated scheduling resource allocation multi project scheduling error detection network analysis features april
top bottom parsing note concerned efficiency top bottom parsing connection programming language grammars shown paths eliminated suitable productions defining grammar essential method complicated syntactic structures practice arithmetic expressions april
pass compilation arithmetic expressions parallel processor assumption processor arithmetic units compiler processor produce object code advantage parallelism operation compilation techniques processor produce expression structures evaluated technique presented compiling arithmetic expressions structures evaluated high degree parallelism called top analysis technique requires pass input text april
proposal definitions algol extension algol proposed data types operators language definitions occur block block integral part program fixed language behavior existing operators processing text defined contexts features replacement rule storage examples definition sets real complex matrices complex numbers file processing list manipulation april galler perlis
generating root diagrams technique digital ordinary time root diagrams ordinary diagrams drawn faster accurately time diagrams obtain drawn speed accuracy ordinary diagrams
tensor calculations main text paper comm acm formac program discussed capable calculating quantities interest tensor calculus intended program output symbols calculated basic orthogonal coordinate systems
eigenvalues eigenvectors symmetric f2 boothroyd
determination square root positive definite matrix f1
error free methods statistical computations discussed computational error generated algorithms compute statistics present paper methods error free simple concept machine time mentioned
methods evaluating polynomial approximations function evaluation routines method nested multiplication commonly function evaluation routines evaluate approximation polynomials polynomial evaluation methods developed recent years require fewer nested multiplication function evaluation routines methods rounding error difficulties methods evaluating low degree polynomials found satisfactory methods illustrated file
typesetting algol application aided typesetting introduced working method algol computerized translation hardware reference representation computerized planning computerized control typesetting machine point made science technology programming correct algol documentation valuable time power considerations
efficient procedure generation closed subsets efficient generating subsets set satisfy constraints form subset subset programmed language successfully run ibm connection routine feedback multidimensional iterative networks
application formac nonlinear circuit analysis problem stated solved formac solution problem formac methods problem straightforward hand involved formac language program large utilized command made extensive part command order formac paper concerned programming techniques formac actual engineering problem readers problem stated general mathematical sense interest areas circuit analysis
automatic examples automatic storage explicit array declarations
automatic simplification source language programs methods simplification applied automatically programs written algol language discussed based form program knowledge obtained processor understanding program methods implemented processor called accepts program written equivalent program executed faster original problems encountered automatic improvement source language level discussed types automatic program improvement suggested clark
structure lisp level storage list processing core memory data programs paper number techniques lisp drum principal storage medium low time slow storage device techniques include segmentation programs allocation virtual memory address arithmetic type determination special building lists scheme binding variables good environment complete compatibility compiled programs special declarations
application level changing multilevel storage organization technique organizing devices storage technique called multilevel store means requirements large storage data management information retrieval systems concept level changing introduced application multilevel store discussed means organizing information efficient multilevel store presented
programming deals variety activities carried people great variety part activity distinct professional field scope economic social educational characteristics means defined paper issues examined expressed
programming package package fortran statistical programs small medium size characters words fortran ii compiler exists availability major design criteria ease ease modification flexibility input detail output
representation regions region union points set sort skeleton region storage required represent region comparable required represented encoding boundary skeleton representation advantages determine points region perform set operations regions
testing random number generator numbers produced random number generator general purpose systems statistical tests tests results tests presented tests numbers satisfactory recommended suitable tests applied random numbers simulations
programming tabular method analysis variance factorial experiments ease programming tabular method analysis variance complete factorial experiments fortran language demonstrated method total sum squares orthogonal single degree sums squares main effect interaction sums squares obtained single degree sums squares program segments procedure presented modifications handle hierarchical designs experiments mentioned fortran ii program ibm briefly
modified newton method polynomials modified newton method polynomials discussed assumed approximations roots polynomial variations roots simple shown conditions variations
bits digit accuracy represent digit decimal floating point numbers accurately bit floating point numbers significant bits represent digit numbers accurately general show significant bits digit decimal accuracy finally define compact bit floating point representation give significant bits numbers practical importance
parameters pseudo runge kutta methods object note present choice free parameters fourth order pseudo runge kutta methods involving points choice parameters bound principal part truncation error term minimum fourth order method minimum order method
invariant numerical integration boundary problems linear systems ordinary differential equations diverse areas transfer optimal control point boundary problems systems arise greatly numerical solution invariant technique presented frequently encountered results numerical experiments
problems statistical analysis simulation experiments comparison means length sample records research continued statistical analysis simulation experiments time series shown estimate lengths sample records needed large sample results measuring stability data independent test difference experiments suggested shown variance sample generating process estimation quantities interest results statistical spectral analysis applied simulation experiments
sorting replacement selecting sorting replacement selecting expected length sequence element proved number memory cells expected length sequence determined times degree polynomial polynomial approaches approaches recursive formulas obtained standard deviation length sequence mathematical proofs results based assumption number items infinite shown error due approaches increases
exponential curve fit e2
generalized fit orthogonal polynomials e2
fast slow memories list processing languages scheme substantial increase memory space utilized store list structured data consists reducing level store fast core slow disk drum memories space slow memory divided pages number machine words reduction level memory performed program called pages fast memory page slow store page core period back slow store complete scheme implemented connection lisp algol ibm core memory memory space programming applications price additional space time access time times core tests actual slow depending number pages fast store
time sharing small memory techniques make time sharing small central memory presented small user program monitor fit memory time techniques levels secondary storage level times larger main memory fast level times larger level fisher
improvement iterative methods polynomial factorization methods polynomial factorization find zeros time require division polynomial factor shown accuracy division increased order variable point minimizes simply calculated error criterion january
computation squares polynomials rounding error digital computation squares polynomial makes computed polynomial approximation true square polynomial simple method constant term computed polynomial approximation true squares polynomial january
note computing approximations exponential function methods discussed result minimax rational approximations exponential function time desirable property approximation values argument approximation positive values methods lead approximations superior commonly gaussian continued exponential coefficients errors intervals january
compiler diagnostic fortran implementation basic fortran extensive error checking capabilities compilation time execution program improved diagnostic capabilities objectives compiler discussed attention design implementation techniques employed provide diagnostic features handling error messages general macro approach special features provide teaching aids noted january
university fortran iv compiler core load compiler implemented ibm operating fortran iv selected source language order achieve maximum language compatibility compiling systems ibm fortran iv principal advantage compiler fortran iv programs statements compiler core overhead large student programs processed efficiently compiler extensive error compilation execution program run feature makes users january
uniform random g5 january
data directed input output fortran statement similar statement fortran iv incorporated fortran compiler fortran implementation greater flexibility simplicity fortran iv feature names location mode dimensions variable means standard fortran statements methods information illustrated relation general purpose data directed input output routines matrix manipulation discussed january
computational method analysis complete factorial experiments computational method calculation sums squares analysis variance complete factorial experiments computation main effect interaction means method method variety purposes previously requiring methods programming advantages method obvious discussed standard analysis variance analyses levels factors separate analyses levels factor combinations levels factor performed simultaneously calculation main effect interaction means data standard order data order analyses data performed total sum squares sum squares polynomial partitions interactions degree factors factor levels january
interpretive input routine linear programming descriptive article input code presented greatly data input linear programming solution routine subsequent device solving small problems limited inherent limitations code efficiency evaluation large problems input suited data handling input code user input appears presentation problem limited write input interpreter column fixed format data preparation required user general requirements comments input aid identification row constraints article includes examples input output solution routine skeleton flowchart input interpreter january
code numeric information processing applications online systems code specifically designed simplify internal information processing operations online respect numeric applications transfer rate information channel linking user code direct application problems area information retrieval document classification aided teaching text editing code called information processing code bit code set constructed bit subsets easily derived basic set code set organized simple binary operations numeric special symbol control character codes number characters basic set size codes included set suitable interpretation codes basis requirements local environments january
performance evaluation survey state performance evaluation reviewed evaluation goals problems examined turnaround availability defined fundamental measures performance overhead cpu speed perspective instruction tools discussed encountered analysis simulation synthesis presented levels approach evaluation requiring greater information central role measurement performance evaluation development evaluation methods january
university educational program science power computers science defined ways objectives science education stated american university achieved science department program university reviewed include ph examinations science department january
code extension procedures information interchange proposed usa standard december standard code code information interchange characters shift shift data link control functions standard procedures code extension code table bit pattern
procedures standardization process proposed usa standard december standardization procedures criteria
implementation time sharing simple mechanism execution part program memory protection program improved version time sharing feature december operating memory protection time sharing multiprogramming monitor
analysis algorithms programming problem paper concerned examination existing algorithms programming problem computational experience summarized machine time storage requirements algorithms compared test problems small intermediate size experiments provide solving problems variables amount machine time december operations research optimization theory integer programming variables algorithms
computational linguistics ph science program report recommendations curriculum computational linguistics ph science program classification subject areas contained computational linguistics presented ten courses areas basic computational linguistics december computational linguistics mathematical linguistics language language data processing computational linguistics curriculum computational linguistics graduate program computational linguistics science curriculum
index subject algorithms december
d1 december numerical integration multidimensional integration gaussian integration
eigenvalues eigenvectors real general matrix f2 december eigenvalues eigenvectors roots vectors method qr inverse iteration
generator random numbers poisson distribution g5 december poisson distribution random number generator monte carlo
equations mathematical physics symbolic manipulation method digital derive equations mathematical physics coordinate user effectiveness technique demonstrated derive equations motion equation derive equations method user coordinate transformation equations relating interest orthogonal program coordinate transformation equations input derive equations equation equations obtained relative coordinate transformation equations input paper emphasis theoretical considerations methodology programming details results presented coordinate systems december formac equations equation tensor tensor equation coordinate systems fortran symbolic manipulation
automatic generation efficient lexical processors finite state techniques practical application theory finite state automata automatically generate lexical processors tutorial article developed part accepts input description items words language terms subset regular expressions output lexical processor string characters items defined regular expressions output item identified code number block storage characters character count item processors produced based finite state machines state machine unique condition lexical processing character string state character read machine state transition actions based character read operation processors generated compared speed hand coded programs task lexical processors produced techniques employed independent nature items evaluated word events character string processors generalized decision making mechanisms based ordered sequence events range applications area lexical processing convenient advantages speed important consideration designing automatic generation lexical processor goal processor completely eliminated fast hand coded processors language errors convenient easy december johnson character string compiler finite state automata finite state machine lexical processor nondeterministic machine parsing structure regular expressions sequential machine syntactic analysis
solution linear programs variables implicit enumeration november linear programming variables partial enumeration
roots polynomials root resultant routine november root roots polynomial equations polynomial zeros root operations method resultant procedure procedure testing roots criteria
algol procedure fast fourier transform arbitrary factors c6 november singleton fast fourier transform multivariate fourier transform fourier series harmonic analysis spectral analysis orthogonal polynomials orthogonal transformation virtual core memory permutation
algol procedures fast fourier transform c6 november singleton fast fourier transform complex fourier transform multivariate fourier transform fourier series harmonic analysis spectral analysis orthogonal polynomials orthogonal transformation virtual core memory permutation
bit codes environments tutorial standard november usa standard card code punched card punched card code patterns patterns assignment punched card systems
rule design implementation problem rule evaluation area presented permits user define line sets rules framework presented patterns english define features define data strings structure test effect rules data store definitions results rule application facility detail implemented linguistic rules rules format directed list processor embedded lisp made construction easy providing sophisticated capabilities written lisp scientific data designed line interactive control user command executed november rule linguistics transformational grammar lisp format directed list processing line systems
practical error coefficients integration periodic analytic functions rule theoretical practical values error coefficients error periodic analytic functions rule parameters november theoretical error coefficients practical error coefficients numerical integration periodic analytic functions rule roundoff error truncation error integration
approximate solution initial boundary wave equation problems boundary techniques boundary technique proposed treatment initial boundary problems linear nonlinear wave equations examples offered demonstrate ease method applied november initial boundary problem wave equation boundary technique
line random number generators combinations line random number generators generators requiring single fortran instruction discussed short fortran programs mix generators provide methods incorporating random number generators directly fortran programs means line instructions advantages speed avoiding linkage subroutine experiment generators generators generators provide statistical properties library generators simple fortran program discussed november random number generation monte carlo simulation
note estimate improvement paper effect improvement procedure examined shown applications improvement factor time factor scale factor november information retrieval indexing classification
compiler extensive software problems organization number computers frequently developed written high level language minimizes machine language compiler language discussed language called fortran tree pass compiler makes notation pass pass ii tree representation table pass pass iii machine independent optimization occurs pass ii loop machine dependent optimization pass iii november compiler compiler compiler machine independence scatter storage technique processor common tree representation optimization
storage organization programming systems program data representation university years logical storage block consecutive memory locations block program data vector blocks form arrays storage arrangement discussed realized advantages programming systems simplicity programmed addressing flexibility data structures efficiency memory utilization composition execution means linkage programs programs data basis storage protection application blocks extended areas time sharing storage control basis experience ideas extensions presented november storage allocation storage organization storage control data representation program representation data structures storage protection addressing mechanisms paging segmentation file handling
automata formal languages abstract switching ph science program number courses area describe automata formal languages abstract switching ph student science description applied role courses graduate program discussed november ph science curriculum ph science program automata formal languages switching theory theory
fast fourier transform real series procedure presented calculating complex discrete fourier transform real time series procedure number points series integral power order fast fourier transform reduction computation storage achieved series real discussed hardware software implementations perform log2 complex operations require real storage locations analyzing point record october fast fourier transform time series analysis digital spectral analysis real time fourier analysis discrete fourier transform digital analysis fourier analysis fourier synthesis
general purpose display processing tutorial display processing tutorial designed improve man communications employing display unit operations simulation programming information retrieval written fortran iv ibm model ibm display unit operating program standard operating automatically resources control operating perform jobs power flexibility assisted instruction making students users full resources programs operating language processors compilers simulation models mathematical solution techniques stored data library user programs incorporated material applications presented implications discussed october assisted instruction tutorial systems programming simulation modeling information retrieval operating systems graphics displays man machine interface line computing graphic programming
easy english language information retrieval remote typewriter console easy english natural command language designed simplify communication man machine remote typewriter console developed retrieval documents computerized data base moore school information systems laboratory files requests formulated form examples presented form equivalent query expressed retrieval original symbolic command language briefly operation easy english detailed transformations performed sample request point request string macro flowchart easy english included retrieval october natural language communication line searching remote console communication information retrieval man machine communication remote terminal communication translator document retrieval conversational mode information retrieval language symbolic command language
implementation basic multiprogramming environment implementation remote terminal basic context existing multiprogramming implementation unique machine language interpretive techniques incremental compiler october multiprogramming incremental compilation compilers interpreters
boolean matrix methods detection simple precedence grammars mechanical procedure derived determining context free phrase structure grammar simple precedence grammar procedure consists elementary operations defined boolean matrices application procedure operator grammars october syntax analysis precedence analysis simple precedence grammar simple precedence language operator grammar operator precedence compilers bounded context syntactic analysis boolean matrices relations
ambiguity limited entry decision tables decision tables tool systems analysis program specification rules redundancy limited entry tables published checking conversion extended limited entry form processors automatically tables conventional program base diagnostic facilities rules paper suggested rules important checking eliminate ambiguity tables ambiguity defined discussed procedure producing decision tables proposed theoretical basis established importance designed diagnostic facilities decision table processors october decision tables systems analysis
generating analyzing activity networks generating activity networks designed time preparation activity networks deal network programs defining description programming language designed generating activity network set standard networks presented general idea language performing calculations activity networks scheduling activity networks october activity network management project standard network network generator network activity network analysis network calculation network program
synthesis display digital reviewed mathematical model computational techniques authors digital process discussed applications suggested made dimensional objects give light approach based point image discussed images digital presented october fourier transforms applications display device physics mathematics image processing
september network linear programming minimum cost flow network flow
september network linear programming minimum cost flow network flow
calculation polynomial derivative values scheme september function evaluation polynomial evaluation algol procedure scheme
september network linear programming minimum cost flow network flow
comparison behavior random number generators ibm states prime pseudorandom generator usual statistical tests random number generators shown generators type produce sequences functions evidence constants alternative generator proposed polynomials field characteristic shown free applicability generators ibm discussed word size generator statistical behavior mixed simple generators tested computers bits word optimum generators ibm september random numbers pseudorandom number generators function serial correlation digital shift register generators linear recurrence polynomials primitive generators prime numbers statistical tests ibm bit bit word size
numerical solution transfer problem numerical solution linear equations resulting discrete approximation transfer problem considered slow convergence point iterative methods analyzed shown caused boundary conditions difficulty standard line iterative technique september iii transfer problem poisson equation boundary problem successive block
general purpose language general purpose programming language facilities constructing language data types facilities operations performed basic language minimal sense basic element derived high efficiency object programs constructs algol statements statements basic special types procedures symbols words algol defined usage declarations part words words handled easily full words address variables pointers included full september programming language general purpose macro algol
probability union large number events presented efficiently probability union independent events problem evaluating sums products combinations variables minimum time storage space september probability optimum storage time set union events
line modeling networks description presented enables user construct network output data produced network store networks data library digital display unit directly user permits easy rapid modeling process designed complement research systematic development models experimental work networks built components representing individual external component detailed nature made experimental data input network convenient means specification modification network extensive error checking capabilities provided data resulting simulation network analyzed variety techniques examinations characteristics data determination detailed statistical properties september modeling data analysis discrete simulation library systems modeling network simulation networks models line simulation simulation
states stochastic matrix states stochastic matrix presented applications markov programming construction variable length codes reviewed updating procedure sequences stochastic matrices discussed computation times investigated compared recently method september stochastic matrix chain identification
graphical input output characters developed characters printed principle deal present limited characters mathematical symbols characters added graphical input display scope text accomplished display scope organization operation current discussion relative input output characters included september characters input output pdp automatic typesetting man machine communication graphics graphical input line editing
statistical model console behavior computers ability world efficiently important ability perform computations efficiently difficult user easy entire user community based properties community virtual console made virtual console actual console entire collection virtual models collection actual model answer questions processes console input maximum rate process execute bounds set buffer requirements similar questions needed aspects operating design september denning statistical models input output operating design input output design
experimental evaluation information retrieval experiments designed evaluate capabilities information retrieval systems emphasis interactive man machine language mechanical limitations design conducted moore school information systems laboratory basic assumption research information retrieval man machine remote terminal provide tools performing search library documents factors involved evaluation include ease learning time effectiveness actual retrieval experiments conclusions resulting detailed september information retrieval testing information evaluation experimental document retrieval document retrieval document man machine communication remote console communication communication remote terminal communication retrieval command language symbolic command language interactive systems user learning factors line searching
punched card natural language searching idea punched card information retrieval methods idea produce programming technique run time half test search subject index entries search program device operational item store mask created item words operation search time logical product operation mask constructed question mask equal question mask question words present store item words store item compared question words present store made subject index entries average characters longer handled multiple september coding natural language searching text searching information search technique
rates data transmission proposed usa standard august
paper august jr
standards identification programming languages user public standardization reliable identification programming languages related services goals illustrated methods interactive language related family languages standardization technique user local variations language explicit standardization language source language published standards services reliable public identification methods applied programming languages services august standardization programming languages language public identification programming languages standards
minimum cost curve august critical path scheduling pert cost time network
set basic input output procedures means primitives symbol length algorithms policy comm acm basic set input output procedures defined quality flexibility written derived procedure fixed point floating point representation easily written explicit call procedures integer real highly recommended practice input made easy subset derived procedures documentation output form equivalent algol statements provided made subset style providing information form output calls procedures real format defined parameter provide information simultaneous output suggested procedures tabular form august input output input output procedures input quality output integer real style style procedures relationship output documentation equivalent algol statements algol algol integer format real format integer read real input output boolean input output array fixed point representation floating point representation output channel interpretation
character manipulation procedures programming language facility symbol manipulation string procedures called standard algol context algol procedures called string procedures numeric symbolic processes programmed pattern matching make set primitive commands conditional expressions provide alternative computational patterns arrays strings processed class things assigned restricted procedure expressed notation language facilities implemented algol compiler august symbol manipulation string handling character manipulation conditional expressions procedures structure matching recursive programming
generation positive test matrices positive sufficient conditions real matrix similar positive matrix result construct similarity transformation applied upper triangular matrix yields positive matrix positive august test matrices positive matrices similarity transformation positive eigenvalues
note efficiency lisp computation paged machine problem levels storage programs context lisp core memory buffer large virtual memory stored drum details timing problem august storage management list processor implementation lisp paging secondary storage utilization efficiency paged computation
modification technique regression analysis computational technique multiple linear regression requires storage matrix data number variables large requirement storage capacity matrices involved permits modification requiring half storage computations conventional additional storage analysis problems variables permits analysis problems number variables computations performed double precision august multiple linear regression statistical recurrence formulas correlation linear statistical models statistical programs curve fitting
implemented associative structure package general purpose associative data structure package arbitrary number data items arbitrary number relationships data items represented special picture language proved drawing structures paper structures built means series macro calls outlined emphasis philosophy implementation sufficient information included produce implementation august gray associative data structure structure lists list structure set languages modeling graphics
discussed legal explained users operators computers potential legal problems focus data processing services record operations operations relating record information protection programs problem material information storage retrieval systems including august iii law legal accounting simulation standard record records evidence copying
recovery disk contents method discussed contents disk files status time august data disk file organization error recovery file organization
high priority multiprogramming systems case high priority occur multiprogramming systems scheduling based primarily scheduling number programs active time case paper general methods increased scheduling future improvements considered briefly august scheduling dynamic priority assignment scheduling
procedure normal distribution s15 july normal distribution function error function normal function normal curve integral
direct search e4 july function minimization search direct search
normal random g5 july bell normal normal distribution random number random number generator simulation probability distribution frequency distribution random
generating prime encoding decimal arithmetic decimal arithmetic encoding topological considerations obtain prime boolean functions programmed fortran language generally requires memory minimization procedures terms efficient manner july prime switching function minimization encoding
logical arithmetic computers complement binary arithmetic algorithms presented multiplication division integer digits significant arithmetic digits positive july binary arithmetic arithmetic maximum significance arithmetic full precision arithmetic
methodology calculating optimizing real time performance increasing size complexity number types cost data processing systems examination government industry criteria methods calculating optimizing data processing cost performance real time data processing systems automated discussed paper criteria evaluating performance methodology calculating optimizing outlined method illustrated portion performance calculation optimization drum oriented message switching july real time analysis real time design real time performance criteria real time cost performance ratio
master level science curricula results survey work master degree universities presented general comments emphasis programs july education science curricula
determination intersection points plane curves means differential equations method proposed intersection points plane curves theory singular points differential equations developing method intersection point determined identified singular point modifications applied singular point stable integrals start singular point approach point integral parameter addition method searching intersection points rectangular area july plane curves intersection points plane curves integration differential equations matrix iteration singular points nonlinear differential equations eigenvalues complex roots roots points runge kutta stable
methods convergence improvement integrals numerical integration integral kind integral change iteration constant efficiency integration schemes improved recent theory nonlinear transformations important integrals integrals rational polynomials transformations yield improvement paper methods convergence improvement developed greatly improve convergence integrals including integrals rational polynomials july approximation nonlinear integral convergence improvement numerical integration rational polynomials truncation
construction project networks project networks pert constructing project networks directly project precedence relations activities orders nodes number nodes created minimal precedence relations programmed fortran ii ibm july fisher project networks pert topological ordering network construction
generalized partial pass block sort design partial pass block sort arbitrary range key number work files design generalization partial pass column sort sort power sort sizes input file number work files consideration problem combining block sort internal direct access storage devices july block sort partial pass sort direct access devices column sort chaining reverse chaining sort
simple proof ordered retrieval theorem associative memories efficient method ordered retrieval binary words associative memory based special circuits digit values present individual digit memory circuits individual digit digits values digits memory circuits paper column reduces considerably number memory accesses order number distinct words memory method distinct binary words memory accesses number memory accesses method methods independent word length paper simple proof theorem derived elementary aspects structure sets binary numbers presented july associative memories content memories ordered lists ordered information retrieval ordered retrieval theorem column digit values digit variety column arrangement digit digit variety memory access memory access frequency ordered retrieval efficiency access frequency proof retrieval theorem proof
preliminary investigation techniques automated text methods converting printed material code investigated operator controlled mode depending human regions page implemented means display mode performance obtained suitable processing complicated material technical simpler material sections applications accuracy mode page rapid form frequency analysis areas higher resolution suitable character recognition error rates order percent obtained simple problem involving telephone related design general purpose page segmentation printed text possibility time sharing interactive man machine operation discussed july pattern recognition character recognition text information retrieval text operator controlled online text image machine
estimating frequencies program segmentation program estimation values ij ij number instruction instruction run time cases ij directly structure program generally account difficult programmer translator obtain good estimation ij estimate ij quantities ij ij sum ij arbitrary positive constant ij proportional ij estimation ij estimate probabilities events instruction executed instruction estimation structure program part paper theory markov computation ij ij found ways obtaining estimates ij part derived avoiding computation involving large matrices july object program reduction supervisor calls jump frequencies estimation control estimation optimal program segmentation markov chain program correspondence program graph entry jump frequencies supervisor overhead program segmentation jump frequencies program segmentation problem
experimental data behavior programs paging environment results summarized empirical study directed measurement program operating behavior multiprogramming systems programs organized fixed length pages data interpretive execution number paged programs describe frequency page frequency executing program requires page data instructions main core memory data evaluation page replacement algorithms effects performance amount storage executing programs july paging systems paging dynamic program behavior program behavior virtual memory systems single level storage level storage operating simulation operating systems supervisor simulation machine language program interpretation
linear programming june linear programming dual simplex method primal problem dual problem
jacobi polynomials s22 june jacobi polynomials orthogonal polynomials term special functions
gaussian quadrature formulas d1 june gautschi quadrature gaussian quadrature numerical integration function orthogonal polynomials
factorial analysis variance june factorial variance analysis variance statistical analysis
distribution objects g6 june object distributions combinations distribution numbers
chebyshev solution linear f4 june chebyshev solutions linear systems linear equations
time method time price time demand relative priority users controlled important access free periodic time allocation schemes june scheduling time allocation operating efficiency
format data transmission tutorial standards june data transmission format format message format data transmission message
global parser context free phrase structure grammars june
writing outline debugging program user online debugging routines user require complicated make difficult user correct errors memory features debugging program prime importance program simple flexible highly efficient communication user debugging program improved techniques applicable online debugging programs techniques presented illustrated package debugging program coded pdp economy utility program core storage debugging features discussed june debugging utility program programming languages
regular expression search method specific character strings embedded character text implementation method form compiler discussed compiler accepts regular expression source language produces ibm program object language object program accepts text input produces signal time embedded string text regular expression examples problems solution presented june search match regular expression
braille terminal device active time shared facilities blind programmers requires braille terminal details construction model head increasing description programming needed drive presented june blind communication blind programming aid braille braille communication braille output braille braille terminal braille type head communication terminal
raster display display designed displays low unit cost raster display console plot points characters initial display display costs technique employed generating binary image desired display image written drum memory independent read display picture generated lines standard monitor display device technique compute image displayed interaction difficult function point inverse map generation process required point inverse map generation process required selected point input space june display graphics raster display display console digital display raster display raster display graphics terminal graphics graphic terminal
design display processors flexibility power needed data channel display considered work efficiently channel sufficient number instructions small processor powerful channel found successive improvements display processor design circular path making improvements original simple design general purpose degree physical display key factor display processor design june display processor design display graphics graphic terminal displays graphics display generator display channel display programming graphical interaction remote displays
reliable full duplex file transmission half duplex telephone lines field scheme reliable duplex transmission half duplex communication line presented demonstrate difficulty problem similar scheme slightly presented flowchart reliable scheme interesting examples june telephone communication half duplex transmission error correction full duplex telephone errors
stable numerical methods obtaining chebyshev solution equations implementation determining chebyshev solution linear equations presented gaussian lu decomposition row implementation computationally stable literature generalization developed permits equations simultaneously june chebyshev solutions linear systems linear equations
position paper computing communications effective operation free information service industry dependent restructuring information processing industry division costs made computing communications development information services wide concepts information services share cost construction development public message communications services made information security information networks information systems computing free computing management government communications services distributed data base program
protection information processing utility critical problems design information processing utility permits flexible sharing user information privacy solution problem discussed graham protection privacy information processing utility time sharing multi user multiprogramming multiprocessing security shared information controlled access reliable operation segmentation
criteria designing computing systems facilitate debugging designer computing explicit criteria proposed features criteria kind input input output criteria user control content extent output define scope criteria notion abstract machine programming language notion virtual explained examples applications criteria time day synchronization parallel processes protection multiprogrammed systems assignment capability van design design criteria systems systems design input equipment input equipment design operating systems operating systems design multiprogramming multiprogrammed systems multiprogrammed design virtual computers programming languages programming language design program semantics programming language semantics deterministic computers protection memory protection information security information privacy computing reliability debugging program debugging program testing parallel processing parallel programming multiprocessing
scheduling philosophy multiprocessing systems collection basic ideas presented past years provide suitable framework design analysis multiprocessing systems process state vector discussed nature basic operations processes considered processes protection analyzed general approach priority oriented scheduling relationship conventional interrupt systems explained aspects time oriented scheduling considered implementation scheduling mechanism analyzed detail feasibility hardware established finally methods execution independent processes presented compared time sharing multiprocessing process scheduling protection priority interrupt systems
structure multiprogramming multiprogramming activities divided number sequential processes sequential processes hierarchical levels independent abstractions implemented hierarchical structure proved verification logical design correctness implementation dijkstra operating multiprogramming hierarchy structure real time debugging program verification primitives sequential processes levels input output multiprogramming processor sharing multiprocessing
considerations design multiple extended core storage large quantities fast random access memory multiprogramming performance discussed general design hardware arrangement software components functions based configuration dual cdc share words extended core storage generalization design special emphasis estimating expected compared traditional configuration separate independent computers extended core storage made conventional speed random access storage devices place faster memory multiple systems extended core storage multiprogrammed operating systems multiprocessor operating systems control data corporation operating
working set model program behavior basic general treatment resource allocation systems model program behavior paper model working set model developed working set pages process defined collection recently pages knowledge dynamic management paged memories process working set shown computational activity processor demand memory demand defined resource allocation formulated problem equipment denning general operating concepts multiprocessing multiprogramming operating systems program behavior program models resource allocation scheduling storage allocation
resource management medium scale time sharing operating task scheduling resource medium size virtual memory paging machine discussed relation combined batch processing time sharing environment task scheduling paging algorithms implemented results comparative simulation development algorithms discussion emphasis performance relative characteristics resources simulation results relative hardware characteristics effects program mix loading variations presented time sharing operating systems resource management task scheduling paging simulation memory management virtual memories
virtual memory processes sharing multics basic concepts involved design multics operating introduced multics concepts processes address space virtual memory defined paging segmentation explained means users share procedures data discussed mechanism symbolic references virtual machine addresses detail virtual memory information sharing shared procedures data sharing dynamic linking segmentation paging multiprogramming storage management storage hierarchies file maintenance
dynamic storage allocation systems recent designs hardware facilities provided problems storage allocation method dynamic storage allocation systems functional capabilities provided underlying techniques presented basic purpose paper provide perspective utility hardware facilities survey storage allocation facilities systems included segmentation paging multiprogramming storage allocation storage management virtual memories storage fragmentation storage hierarchies addressing mechanisms
acm operating principles acm special interest committee
punched card code proposed usa standard april usa standard card code punched card punched card code patterns patterns assignment punched card systems
data code calendar date machine machine data interchange proposed usa standard april usa standard data code calendar date machine machine data interchange calendar date data group
symmetric polynomials april mckay symmetric polynomials symmetric sum symmetric functions functions
problem april problem linear programming
normal curve integral s15 april normal curve integral probability special functions
integral s15 april integral probability special functions
s22 april function special functions
roots low order polynomial equations april root polynomial equation roots quadratic equation roots cubic equation roots equation roots polynomial zeros
discussion acm august education design experiments half discussion organized galler perlis making prepared statements discussion van presented papers half discussion remarks papers van discussion half pertinent papers included references april students courses survey courses programming content courses rates teaching social
utilization digital computers research instruction higher education projections education published complete report survey conducted determine utilization computers research instruction institutions higher education united states sampling survey estimates total population presented april computing research instruction utilization support higher education secondary education colleges universities
estimation differential operators eigenvalues linear ordinary differential operator constants number eigenvalues values constants precise formulation provided effective numerical procedure solution results computational experiments april bellman eigenvalues differential operators nonlinear boundary problems inverse problems differential equations identification
general purpose graphic language interactive computers graphic terminals permit problems solved machines order handle variety applications develop general purpose graphic language number graphic devices designed produce language model graphic language developed presented april graphic language interactive incremental compilation language design syntax language
global parser context free phrase structure grammars analyzing context free phrase structure grammar generating program parse sentence language sentence parser top bottom type recursive number heuristic procedures purpose basic input sentence symbols included generating parser implemented snobol tested successfully number artificial grammars subset algol number routines data grammar minimum lengths strings interest application context april parser syntax directed compiler context free grammars syntactic analysis
world computers automatic processing information principal cost problem complexity man machine communication lack understanding distance time size main processing information greater part human work activity production service developments hardware programming time sharing education data communication displays effectively continued rapid expansion problem oriented languages effective entire online computers time sharing rate high measure education increased understanding basic progress complex powerful tool important problems created population analyzing solutions april philosophy developments aided design problem oriented languages data communication education science survey introduction
rules information processing background acm november set guidelines professional information processing codes reasons rules considered sections acm guidelines analyzed purpose important interest professional code acm guidelines professional
curriculum recommendations academic programs science report acm curriculum committee science report recommendations academic programs science developed acm curriculum committee science classification subject areas contained science presented courses areas descriptions detailed courses included specific recommendations committee preliminary recommendations undergraduate programs graduate programs science discussed recommendations presented development master degree programs ways developing guidelines programs discussed specific recommendations made importance service courses education science attention organization requirements resources facilities needed implement science educational programs science courses science curriculum science education science academic programs science graduate programs science undergraduate programs science
dual case keyboard arrangement proposed usa standard
general purpose keyboard arrangement information interchange proposed usa standard
program overlay techniques general features program overlay systems main types automatic programming techniques explained function machine hardware features implementation overlay facility multiprogrammed cdc detail special reference real time applications multiprogramming overlay techniques storage allocation segmentation
inverse symmetric matrix symmetric elements f1 symmetric matrix matrix inverse matrix matrix modification
network programming maximum flow
generation permutations lexicographic order g6 smith permutations lexicographic order lexicographic generation permutation generation
distribution s14 fisher distribution student distribution
test probabilities s14 morris test student statistic distribution function
harmonic analysis distributed data c6 harmonic analysis cosine series series function approximation curve fitting series
translator writing systems critical recent writing programming languages presented formal study syntax application translator writing discussed section ii approaches syntactic semantic aspects translator writing discussed section iii related topics section iv compiler compiler compiler translator translator writing systems syntax semantics syntax directed meta parser syntactic analysis generator
numerical integration formula fourier analysis numerical integration formula presented sampling intervals intervals log scale formulation fourier analysis improve accuracy ease usage complete set formulas numerical fourier analysis january numerical integration fourier analysis integration
conversion floating point number base floating point number base back floating point number original base combinations rounding truncation question considered significant digits needed intermediate base original number significant digit january floating point numbers significance base conversion rounding truncation
practical error coefficients estimating quadrature errors analytic functions published error coefficients estimating quadrature errors analytic functions computed assumption quadrature rule exact polynomials degree rules values true values integrals polynomials question infinite binary expression quadrature rule exact errors consideration computing practical error coefficients january numerical integration quadrature truncation error theoretical error coefficients practical error coefficients integration analytical functions roundoff error
scatter storage techniques scatter storage techniques method implementing symbol tables compilers reviewed number ways effectively presented techniques january morris scatter storage hash addressing searching file searching file addressing storage layout
improved hash code scatter storage introduced hash coding method based fixed point division multiplication logical operations method hash table length method handling discussed quadratic search method faster random search free linear search january hash code hash table scatter storage searching
transition matrices compiling algorithms constructs suitable grammar efficient left sentences language type number compilers operates pushdown stack transition matrix examples illustrate effectively purposes usual syntax checking january transition matrices compilation translation grammar context free language formal language parsing
general processor programming languages made develop implementing higher level programming language construction compiler proved generally satisfactory paper programming language macro instructions macro call form terms programming notation discussion logical role macro instruction presented discussed conflict machine independence object program efficiency question greatest difficulties compiler construction january programming language translator programming language processor general translator general processor macro instruction processor meta processor meta language translator meta language processor compiler compiler writing translator writing
logarithm gamma function s14 january hoare
method finding roots arbitrary function january equation roots function zeros
triangular factors modified matrices f1 january matrix decomposition matrix factors matrix matrix
experimental studies comparing online line programming performance experiments conducted development corporation compare debugging performance programmers working conditions line line access studies measure programmers performance controlled conditions standard tasks statistically significant results experiments faster debugging online conditions important practical finding involves individual differences programmer performance problems encountered designing experiments limitations pointed presented account results suggestions made research january online line performance programmer communication programming experimental empirical studies programming cost effectiveness programming performance debugging effectiveness time sharing batch processing factor analysis application programmer performance basic programming knowledge test programmer study analysis variance programmer individual differences
presentation characters information processing proposed american national standard december input encoding upper case hand printed
fast random number generator ibm december pseudorandom number period normalization characteristic square test
optimal code serial parallel computation december code optimization sequencing operations detection common subexpressions
index subject algorithms december index index subject algorithms comm acm
solution linear programs december linear programming variables partial enumeration
coulomb wave functions s22 december coulomb wave functions wave functions special functions function evaluation
elementary functions continued december continued table
s14 december gamma function logarithmic derivative factorial function function
analysis variance balanced experiments december analysis variance analysis covariance regression analysis experimental design balanced experiment data estimate block estimate
regression direct product matrices december analysis variance analysis covariance regression analysis experimental design matrix direct product protection operator orthogonal matrix
complex root finding december method complex relaxation method complex iteration complex equation transcendental complex equation algebraic complex equation
polygonal regions december polygonal regions surfaces drawing pictures regions
multiprogrammed computers progress developing analytic method multiprogramming discussed mode operation programs processor memory central processor unit cpu input output programs priority represent simultaneously effective rate programs effective progress rate program sensitive detailed characteristics simulation method paper presents results progress developing alternative simulation simulation tested iterative computation rates situations sensitive factors control including topological features programs structures december multiprogramming simulation equipment evaluation hardware evaluation monitor operating software performance time sharing time
method method numerical method solving complex equations restriction function analytical introduction method critical relating literature presented theory method shown fundamental exists practical applications avoid difficulty improve rate convergence root modifications original method proposed program fortran based modified method numerical examples included december method complex relaxation method complex iteration complex equation transcendental complex equation algebraic complex equation
optimization expressions fortran method optimizing computation arithmetic indexing expressions fortran program presented method based linear analysis definition points variables loop structure program objectives processing eliminate redundant calculations references made common values invariant calculations loops efficiently compute iteration variables provide efficient index register usage method presented requires pass compiler backward development fortran compilers proved produce object code significantly reducing compilation speed december fortran optimization expressions compilers compilation register allocation loops common subexpressions invariant calculations
advanced techniques computers techniques information processed computers special emphasis unique characteristics files make methods relative security costs methods included paper december van systems security systems information processing
numerical analysis ph science program numerical analysis study methods procedures obtain approximate solutions mathematical problems emphasis scientific calculation difficulties education area center question background emphasis numerical analysis program science department problems implementation experimental procedures solid background applied mathematics december ph program numerical analysis education
automatic programs efficient manual operation program memory discussed measurements brown automatic mechanism simple design demand paging unit built ibm research center quality compared manual discussed shown unit conditions tested operating memory storage interface large speed difference required manual examined number important computing today shown arise source concluded mechanism normal part computing systems december paging automatic paging demand paging automatic storage hierarchies memory hierarchies replacement algorithms performance measurement
case study programming parallel processors partial answer provided question program parallel processor computing systems efficiently execution time problems parallel processor systems multiprocessor systems processors simultaneously execute separate tasks single job solution time computational problem processors independent instruction meaning processor task program independently processors communication processors means data storage shared processors program determination distribution current network written parallel processor computing execution program simulated data simulation runs demonstrate efficient solution problem typical large class important problems shown proper programming solution time processors applied approaches times solution time single processor programming lead increase solution time number processors stability method solution investigated december parallel processor parallelism parallel programming multiprocessor multiprogramming storage interference network simulation relaxation jacobi gauss convergence
fortran random number generators november random number generation monte carlo simulation
generation permutations pseudo lexicographic order g6 november smith permutations lexicographic order lexicographic generation permutation generation
direct search e4 november smith function minimization search direct search
direct search e4 november smith function minimization search direct search
generalized squares fit orthogonal polynomials e2 november squares curve fitting orthogonal polynomials term recurrence polynomial regression approximation method
computation fourier coefficients c6 november ray numerical integration fourier coefficients filon method
legendre functions kind real arguments november legendre function legendre function real arguments
complex error function s15 november gautschi error function complex argument function continued gauss quadrature recursive computation
generation random permutations g6 november permutation random permutation transposition
function square matrix ii g6 november matrix determinant
shortest path topological ordering november shortest path tree network directed graph
factorial analysis variance november factorial variance analysis variance statistical analysis
parse request language language extension algorithmic language pl pattern matching capabilities found special purpose languages capability provided parse requests stated format parse requests form programming language special sequencing rules successfully parse request pl code executed code normal pl strings levels parse normal pl variables information alternatives successful convenient facilities multiple input output sequences parse requests subroutine parse time semantic included convenient building powerful syntax function macro algebraic language debugging line command parser translator programming general string november text processing string processing symbol manipulation pl syntax parser translator pattern matching
practical method constructing lr processors practical method constructing lr processors developed processors capable parsing input single scan number steps equal length input number steps derivation technique presented based original method knuth effort required construct processor size processor produced procedure involves partitioning grammar number smaller parts lr processor constructed part knuth conditions relating individual processors satisfied lr processor entire grammar constructed procedure lr parser algol obtained november lr grammar syntactic analysis parser deterministic language syntax directed compiler language processor context free language algol
lisp garbage collector virtual memory systems paper garbage collection list processing systems operate large virtual memories object active storage free storage free storage decision garbage easily made criteria decision discussed november garbage collector virtual memory list processing storage allocation
performance monitoring time sharing software measurement facility part general purpose time sharing date collection facility implemented terminal model exists purpose monitoring operating user program behavior performance structure outlined order implementation events identified recorded supervisor magnetic tape auxiliary program line processing events user programs actions recorded supervisor call time event accurately recorded data items identified job type overhead data collection interference normal jobs analyzed shown minimal examples information obtained facility applications general guidelines offered construction future monitoring programs november performance monitoring performance measurement program behavior performance data multiprogramming performance software measurement time sharing performance evaluation software monitor software
synchronization parallel accessed data base problem considered data base simultaneously process rules synchronization amount parallel activity allowed assumed data base represented graph data base hierarchy line file methods synchronization processes examined discussed performance compared november parallel parallel search file search data base synchronization deadlock
interactive graphical display monitor batch processing environment remote entry graphic monitor program developed university cdc general purpose batch processing remote entry existing graphics hardware graphic monitor auxiliary monitor comprehensive capability graphical response commands human user commands user program similar interface routine calls place manual actions human program equal basis medium graphic monitor choice made designing graphic monitor constraints existing hardware discussed structure monitor program human program version small part november graphic monitor man machine interaction graphic interface graphic batch environment design graphical
retrieval times direct access inverted file october information retrieval direct access memory data base inverted list
comment optimal tree structures october information retrieval file searching tree structures double chaining
minimax logarithmic error october logarithmic error rational approximation square root
ambiguity description algol october problem sequences
basis programming paper attempt made logical programming techniques applied study geometry extended mathematics involves sets axioms rules inference proofs properties programs examples axioms rules formal proof simple theorem displayed finally argued important advantages theoretical practical topics october hoare method theory programming proofs programs formal language definition programming language design machine independent programming program documentation
programming language language developed students important important features procedure oriented language level block structure variety data types powerful features included discussion design principles student language october languages programming languages student programming systems language design high school programs courses
method determining linear precedence functions precedence grammars precedence relations precedence grammar dimensional precedence matrix information matrix represented pair vectors called linear precedence functions presented obtaining linear precedence functions precedence matrix shown computational advantages october bell boolean matrices syntax precedence grammar context free parsing transition matrix precedence functions
algol procedure based fast fourier transform c6 october singleton fast fourier transform complex fourier transform multivariate fourier transform fourier series harmonic analysis spectral analysis orthogonal polynomials orthogonal transformation covariance cross correlation digital permutation
normal curve integral s15 october normal curve integral probability special functions
singular decomposition complex matrix f1 october singular values matrix decomposition squares solution
efficient prime number generator a1 october singleton prime numbers number theory
prime number generator principle a1 october singleton prime numbers number theory sorting
generating configurations october problem sequences
choice base digital considered memory words state devices sign bits state devices choice base internal representation floating point numbers discussed shown sense october brown floating point accuracy base choice number representations
modular sharing alternative approach design organization general purpose interactive computing presented organization simple arrangement bank computers memory processor pair assigned process terminal jobs computers master control collection distribution messages remote terminals form disk drive connected terminal switching network disk drive connected active terminal user disk drive share terminal users simple manner ratio users computers dependent size power machines computation requirements mix users organization simpler reliable approach time sharing computers potential highly low cost economic configurations range systems sizes order finally problem programs developed remote terminal users run batch compatible computers october multiple terminal systems terminal oriented systems multiple processor systems high availability conversational systems general purpose time sharing systems real time response modular constructed systems modular sharing systems graphics file communications control problem
standardization overlay programs overlay capability generation systems cdc ibm univac systems based actual experience large simulation program short history description program presented standardization minimum capabilities recommended programs operate easily proposal overlay software memory specification concept conditional tree structure concept efficient cost effective utilization memory increased flexibility program structure october overlay partition region segmentation linkage linkage editor standardization memory utilization memory tree structure cdc ibm univac
simulating networks parallel processes simultaneous events occur problems simulating discrete event systems systems conventional digital systems assumed network sequential processes briefly reviewed common techniques handle simulations simultaneous events occur handled simple priority rules problem simultaneous events separate processes introduced abstraction problem developed solution commonly encountered problems technique find method simulating parallel events report found cases shown find solution information solution technique cases technique computationally additional information provided september simulation parallel processes simultaneous events picture processing simulation
finding fundamental set cycles graph fast method presented finding fundamental set cycles finite graph spanning tree vertices examined vertices stored pushdown list examination stage process top element pushdown list edges graph examined tree fundamental cycle added edge tree stage vertices graph large store required time depends type graph involved bounded shown bounds terms storage similar gotlieb superior terms speed similar superior gotlieb efficient random graphs september fundamental cycle set graph cycle spanning tree
taylor series method minimizing sum squares solving systems nonlinear equations e4 september solution equations squares approximation newton method
function minimization e4 september boothroyd function minimization
generation permutations lexicographic order g6 september permutations direct lexicographic order reverse lexicographic order lexicographic generation
generator spanning trees algorithms september spanning trees trees graphs
base programming macro processor base implementation processors programming languages easily implemented computing machines experience programming languages implementation based language machine man machine september macro processing machine independence programming languages implementation techniques
compact list representation definition garbage collection implementation compact lists stored memory pointers convenient permits list compact combination description list representation operators implemented similar lisp garbage collector attempts make lists compact list storage storage unique list garbage collection presented detail classes macros implement finally consideration design factors essential processing implementation september data structure data representation list structure list representation list compact list garbage collection storage macro primitive list operations processing list processing lisp free storage
multiprogramming machine coding organization author interrupt feature computers source programming errors programs making programming scheme presented concept interrupt permits specification concurrent activities manner intended serve basis construction operating systems prime examples programs concurrent activities scheme includes set basic instructions generation termination synchronization parallel processes set routines representing instructions simulating machine organization implemented test ibm programs instructions written presented september wirth multiprogramming parallelism interrupt input output organization file handling
program syntactic analysis english sentences program produces syntactic analyses english sentences respect transformational grammar main features analyzer limited dictionary english words analysis paths simultaneously processing sentence left form representation dictionary grammar outline account analysis procedure techniques size analysis record avoiding dynamic application transformational rules number examples output produced program output includes timing information august syntactic analysis language processing language analysis parsing analysis procedure recognition procedure english sentences linguistics transformational grammar limited dictionary analysis
language simulation program theory language language program designed capable english text text program input text correctly relating explicit implicit text large memory memory semantic network representing assertions world program parts memory found text combining represent meaning text means meaning text program successfully format memory form added memory assertions memory capabilities correctly relating text memory content program needed small number examples assertions capabilities provided program general process language methodology additional information process requires text kind memory structure process assertions capabilities relating text stored assertions automatically capability great sentences future addition single linguistic capability provide large effective knowledge world ability text program strategy presented general theory language august natural language processing natural language program simulation human memory simulation linguistics linguistic performance theory
filon quadrature d1 august quadrature filon quadrature integration filon integration fourier coefficients fourier series
filon quadrature filon quadrature considerable attention analysis round truncation errors includes automatic error control feature august quadrature filon quadrature integration filon integration fourier coefficients fourier series
error bounds periodic splines explicit error bounds periodic spline interpolation developed derivative periodic spline shown fourth order approximation points derivative function august spline interpolation error bounds
algol based associative language high level programming language large complex associative structures designed implemented underlying data structure implemented hash coding technique discussion includes comparison work examples applications language august algol associative programming language data structure
definition facility definition facilities higher level languages users language define operators data types language appears information definitions form definitions written conclusions drawn future facilities august galler graham definitions operators macros higher level language
computing capabilities universities author reports universities november describing university conditions computing activities universities student status solutions students university government allowing university computing service academic activities limited number computers small capacity larger ibm computing science academic programs situation means computing developments universities strong academic resources technological economic constraints developing government emphasis computing capabilities future progress august university education computing science academic programs university computing computing university computing capabilities university student relationship universities universities american universities developing
linear programming july linear programming dual simplex method primal problem dual problem
generation derived test matrix f1 july boothroyd test matrix matrix
algol reference language editor july symbol manipulation
characteristic values solutions differential equation s22 july differential equation function characteristic periodic solution solution
expected lengths sequences generated sorting replacement selecting replacement selecting technique sorting ratio expected length sequence generated technique number memory cells complex variable theory shown average interval sign july replacement selecting sorting sequence lengths asymptotic expected length recursion relation generating function function
obtaining correct input approach information machine form scientific business paper difficulty obtaining correctly key data alternative method suggested rule possibility errors input technique explained illustrated reference working program involves essentially phase errors machine phase july correct data correct input data correction key
block structures addressing garbage collection programming languages included explicit implicit block structures provide programmer addressing snobol constraints introduced modifications snobol resulting desirable constraints addressing function definitions significant number calls garbage collector garbage time function program modifications implemented extension snobol july block structures addressing garbage collection local names snobol
techniques pseudorandom numbers simulation uniform pseudorandom integers construct binary numbers probability bit word bit desired parameter techniques making numbers simulation programming july random numbers simulation boolean algebra bit manipulation
automatic contour map methods contour mapping means digital plotter discussed method presented simple implemented programs small number instructions fortran iv instructions required comparisons methods proposed authors performed fortran iv program implementing proposed method july contour map level lines digital plotting function scanning
chebyshev interpolation quadrature formulas high degree july
algorithms shown method computing related products pricing phase algorithms applications july linear programming revised simplex method multiple pricing product
generating pseudorandom numbers complement machine ibm familiar generator examined context type complement arithmetic ibm series sequences considered relationships established shown sequence positive produced simply conventional approach period loss desirable statistical properties easily generated sequence involving values shown period statistical properties statistical properties sequences related previously established criteria july random number uniform distribution pseudo random number random number generator generator power residue complement arithmetic ibm arithmetic
polynomial spline approximation quadratic programming problem approximation function fitting set data approximating function required sign range approximation studied approaches presented quadratic programming provide constraints derivatives selection function yields fit modified polynomial scheme spline fit july constant sign derivatives polynomials linear constraints quadratic programming splines
generation test matrices sign patterns positive class orthogonal transformations presented members transform positive matrix matrix special sign patterns july test matrices positive matrices sign patterns orthogonal transformations positive eigenvalues
problem design operating systems selection resource allocation policy deadlock deadlock situation resources tasks tasks published solutions handle problem sufficient suggest policies request algorithms presented request light current allocation resources determine request possibility deadlock proofs show conditions algorithms sufficient deadlock algorithms successfully july multiprogramming time sharing scheduling resource allocation
recovery list structures slip reference count based space recovery employed slip list structures explicitly lisp garbage collection schemes free find mark nodes program variables program variables identified list function list slip mark lists programmer modification lisp garbage collector list structures slip july list processing slip garbage collection
note storage fragmentation program segmentation main purpose paper presentation results series simulation experiments storage fragmentation types storage fragmentation external fragmentation loss storage utilization caused make storage large number separate blocks internal fragmentation loss utilization caused rounding request storage exact number words required result general rule rounding requests storage reduce number sizes blocks storage loss storage increased internal fragmentation external fragmentation method segment allocation technique segment addressing advantage result evidence presented advantages method conventional paging techniques july storage allocation storage fragmentation paging segmentation addressing
chebyshev solution linear f4 june chebyshev solutions determined linear systems linear equations
vector stored array june matrix transposition array transposition vector stored array
determination square root positive definite matrix f1 june matrix symmetric matrix positive definite matrix matrix square root
modified romberg quadrature d1 june numerical integration romberg quadrature values rectangle values error bound
space time characteristics programs running paging machine running time programs paging machine generally increases store programs run experiments cases reverse true size store running time discussion behavior case replacement formal treatment presented june paging machines demand paging replacement
transformational grammar comprehensive transformational grammar designed implemented ibm deals transformational model syntax lines aspects theory syntax major include full formal description syntax transformational grammar directed random phrase structure generator lexical insertion extended definition analysis simple problem oriented programming language application transformations expressed paper present general attitudes underlying development important special features references papers detail june transformational grammar natural language syntax language processing language analysis sentence generation lexical insertion computational linguistics syntax
generation optimal code expressions factorization set expressions compiled methods presented increasing efficiency object code produced expressions finding set subexpressions occurs expressions subexpressions factors sequencing procedure applied orders factors expressions information computed correct sequence factors memory minimal amount time assignment executed order minimize total number storage cells required results evaluating factors order make techniques computationally feasible heuristic procedures applied global optimal results necessarily generated factorization algorithms applicable problem boolean switching expressions polynomials encountered symbol manipulating systems june factorization algorithms code optimization sequencing operations detection common subexpressions factorization boolean expressions
recursive relation determinant matrix recursive relation relating leading principal developed determinant matrix numerical included calculating eigenvalues june matrix matrix matrix matrix determinant characteristic polynomial eigenvalues
spline function methods nonlinear boundary problems solution nonlinear differential equation point boundary conditions cubic spline function method suited size dynamic size allocation uniform size error spline typical error method requiring differential equation satisfied points results set difference equations block tridiagonal easily solved relaxation standard methods june boundary problems differential equations finite differences functional approximation iterative methods nonlinear equations spline functions
introducing computing smaller colleges universities progress report technical means routine service smaller colleges universities provided remote terminals central facility access effective educational methodology introducing computing institutions developed experience years network involving institutions discussed include importance separate organization representing small colleges training institutions special programming documentation support users development curriculum means june jr jr network introducing computing graduate education usage academic applications curriculum development project center remote computing
simulation traffic network simulation program deals traffic network large area blocks ten lengths represented list memory transfer block expressed proper formula formula based speed block determined density block speed density curve numerical values simulation scheme point makes trace dynamic behavior traffic variety situations examples actual area june traffic simulation traffic flow traffic network traffic control traffic density intersection signal vehicle network list structure simulation
dimensional display display terminal produced raster display recently developed memory standard monitors produce display images object viewed separate points resulting maps stored separate memory output connected separate monitor image achieved image display interactive viewed large group people time june graphics dimensional display raster display interactive terminal map
degree multiprogramming page demand systems simple stochastic model base understanding relationship number programs permitted share memory degree multiprogramming drum traffic rates central processing unit utilization page demand multiprogrammed time shared systems model key feature property page demand statistics implies page job execution model markov chain analyzed numerically results presented wide range key environment descriptive parameters implications results time shared design programming discussed calculation optimal degree multiprogramming wide range parameters presented june page demand demand paging time sharing multiprogramming models scheduling strategies operating systems memory management
roots polynomials root resultant routine root roots polynomial equations polynomial zeros root operations method resultant procedure procedure testing roots criteria
normal random g5 normal normal distribution random number random number generator simulation probability distribution frequency distribution random
gaussian quadrature formulas d1 hill quadrature gaussian quadrature numerical integration function orthogonal polynomials
regular coulomb wave functions s22 gautschi coulomb wave functions wave functions regular coulomb wave functions
coulomb wave functions s22 coulomb wave functions wave functions
regular coulomb wave functions s22 coulomb wave functions wave functions regular coulomb wave functions
simplex method procedure employing lu decomposition simplex method linear programming lu decomposition round errors computational stability
fortran standards initial progress years effort fortran programming language united states initial study application standard specifications maintenance standards result work initial set interpretations prepared nature maintenance standard specifications interpretations reported usa standard fortran basic fortran programming language standardization language standard specification language standard maintenance language standard language standard interpretation standardization committee
dynamic space sharing systems relationships space program behavior processor efficiency systems presented concepts cost space allocation task defined cost combined develop single parameter unit cost illustrate analytic approach investigation problems space sharing demonstrate method sample problems space sharing storage allocation memory allocation storage management memory management program behavior multiprogramming design allocation strategies replacement strategies demand paging time sharing
automatic scheme simple programming discussion made typical university operating record results programming languages including assembly language controlled scheme made testing programmer data final runs data run scheme mixed programs special recognition operators automatic program programming
chebyshev interpolation quadrature formulas high degree chebyshev polynomials chebyshev interpolation chebyshev quadrature chebyshev points chebyshev zeros interpolation quadrature definite integrals
error estimates gaussian integration analytic functions numerical integration analytic functions error estimates gaussian integration error coefficients error coefficients integral formula chebyshev polynomials
simplex method linear programming lu decomposition standard implementations simplex method linear programming based inverse basic matrix updating inverse step method implementations round error properties paper theoretical background implementation based lu decomposition computed row basic matrix implementation slow good round error behavior implementation appears simplex method linear programming lu decomposition round errors computational stability
automated printed circuit routing program routing sided printed circuit regular pattern lines terminals program routing upper lower top virtual long routing basis conflicts lines effective line usage conflict lower conflict extensions technique control problem obtaining percent discussed routing printed circuit program circuit lines
note reliable full duplex transmission half duplex simple procedure reliable full duplex transmission half duplex proposed scheme compared type recently literature finally comments made group related transmission procedures shown data transmission error correction full duplex half duplex transmission control communications
time sharing batch processing experimental comparison values problem solving situation experimental comparison problem solving time sharing batch processing systems conducted paper study attempt evaluate systems user population aid decision making problem solving programming end statistically significant results equal cost usage systems higher level performance time sharing users significantly lower costs time sharing users work performance level equal batch users users speed problem solving attitudes made time sharing time sharing batch processing user performance man machine communications cost effectiveness line line performance decision making performance user programmer behavior programming experimental empirical studies problem solving research man machine communications man machine
computation numerical integration shown practical compute numerical integration integral representation rule error approximation studied april bessel function numerical integration rule
solving special class tridiagonal systems linear equations presented solving linear equation tridiagonal special form shown fast gaussian elimination method suggested solving systems addition explicit formulas inverse determinant matrix april tridiagonal gaussian elimination central difference
coordination reduction sentence analysis class coordination natural languages considered frame work transformational theory account proposed added syntactic component transformational grammar includes rule conditions applied conditions determining sequence performed solution syntactic analysis problem class grammars outlined precise specification procedure paper inverse form lisp function definitions april natural languages grammar transformational theory syntax coordination sentence coordination sentence coordination coordination reduction syntactic analysis grammar testing program rule testing
simulation systems experimental program systems employed major kinds systems individual block simulated purpose user evaluate effectiveness alternative systems environment april simulation scheduling department management science operations research
functions arbitrary precision s14 april function function function function function function special functions
matrix integer programming f1 april integer programming linear algebra mathematical programming matrix condition matrix
hidden line elimination presented elimination hidden lines representation perspective view convex plane objects picture plane edges objects considered point edge found computing time increases square number edges takes advantage reduced number points automatically object points considered case result obtained simpler april hidden line elimination back line recognition dimensional representation plane objects perspective view machine automatic drawing techniques graphics man machine interaction man machine communication aided design
analysis boolean program models time shared paged environments directed graphs matrices frequently represent logical structure sequences instructions techniques addition data references represented model complete structural specification program represented combined model transformation combined model yields model additional timing information contained analysis models execution yields information valuable determining segmentation instructions data time shared environment initial page loading execution analysis control page april time sharing paging segmentation executive compiler monitor program model
algol procedure fast fourier transform arbitrary factors c6 singleton fast fourier transform complex fourier transform multivariate fourier transform fourier series harmonic analysis spectral analysis orthogonal polynomials orthogonal transformation virtual core memory permutation
distribution objects g6 gray
efficient sorting minimal storage m1 singleton sorting minimal storage sorting digital sorting
test probabilities s14 morris test statistic fisher test distribution function
algol procedure based fast fourier transform c6 singleton fast fourier transform complex fourier transform multivariate fourier transform fourier series harmonic analysis spectral analysis orthogonal polynomials orthogonal transformation covariance cross correlation digital permutation
proposed usa standard data communication control procedures usa code information interchange data communication data communication control procedures data communication termination procedures data communication message transfer procedures data communication error control procedures data communication selection procedures communication communication control procedures communication termination procedures communication message transfer procedures communication error control procedures communication selection procedures link link control procedures link termination procedures link message transfer procedures link error control procedures link selection procedures data link data link control procedures data link termination procedures data link message transfer procedures data link error control procedures data link selection procedures
approach high level languages basic input output support facilities shown technique provide methods programs embedded facilities command language processors operating systems input output high level languages command language
organizing matrices matrix operations paged memory systems matrix representations operations examined purpose minimizing page paged memory shown designed matrix algorithms lead savings number page small part total matrix main memory time examination addition multiplication inversion algorithms shows matrix representation partition page cases fewer page row row representation number page required matrix manipulation algorithms studied function number pages main memory jr matrix algorithms array processing paging algorithms paged memory systems virtual memory systems array storage allocation storage allocation
concepts contour map processing generalized techniques simplify solution problems relating contour maps techniques makes topological properties contour maps represented graphical structure contour lines connected nodes generalized technique consists properties determine characteristics lines drawn contour map techniques applied problem obtained map contour map contour lines topological properties properties graph contour map
description format text processing program format production program editing documents directly small features good performance free form input flexible capabilities including page automatic aids index construction minimum items written fortran iv text processing indexing documentation text editing frequency dictionary vocabulary
information science ph science program report recommendations sample curriculum general area information organization information design ph science program subject area briefly desirable graduate level courses suitable curriculum graduate courses university courses science curriculum information science information organization information retrieval data retrieval language analysis information processing
simulation activity digital networks technique simulating detailed logic networks large active digital systems essential objectives improved ease economy model generation economy execution time space facility handling simultaneous activities main results obtained structural model description reduction manual tasks converting boolean logic structural model elimination manual processes simulation activity event scheduling technique economy event queue length simulation procedure deals effectively serial simultaneous activities time simulated precise systems simulated combinations logic aspects techniques simulation network structures digital networks simulation logical simulation digital simulation large systems simulation network structures scheduling simultaneous activities parallel events
images computers digital computers widely processing information data kinds including information contained graphical representations efficient conversion facilities graphical information retrieving graphical form needed commonly employed devices obtaining graphical output digital computers plotter present models producing images continuous gray scale half note programming techniques obtaining half pictures plotter control digital examples methods images half pictures processing
extremely random number generator extremely subroutines needed quality efficiency occurs library functions random number generation core sorting literature random number generators requirements sort extremely line fortran program provided based important paper methods fourier analysis applied probability function consecutive provided generator equal small quality generator high generator compares bounds established mentioned paper random number generators random numbers random number analysis random generators linear sequential generators random number program pseudo random numbers
interval arithmetic determinant evaluation testing chebyshev recent papers smith shown interval arithmetic effectively bound errors matrix computations present paper method proposed smith compared straightforward determinant evaluation computational results show accuracy running times expected determinant evaluation application program test set functions form chebyshev presented smith interval arithmetic range arithmetic error bounds determinant evaluation chebyshev mathematical proof
logarithmic error newton method square root problem obtaining optimal starting values calculation square root newton method considered pointed relative error measure fit optimal results obtained initial approximation fit shown called logarithmic error initial fit optimal types error logarithmic error appears simplify problem determining optimal initial approximation square root newton method relative error logarithmic error fit optimal approximation error recurrence relation integer root error curve
coding pseudo random number generator coding technique presented evaluation pseudo random number generator prime number produces numbers bit greater computation method limited problems modular arithmetic prime factorization primitive root prime number construction pseudo random number generator increased cycle length pseudo random number random number modular arithmetic uniform probability density uniform frequency function simulation prime factorization primitive roots
arithmetic expressions trees description tree representing evaluation arithmetic expression drawn number needed computation represented straightforward manner representation reduces choice order computation specific problem theory graphs solve problem presented arithmetic expression compiler design graph theory programming storage minimization topological ordering tree
binary search technique mathematical model developed variance number document received list files search method binary nature potential information retrieval systems binary pattern file examination graph theory information retrieval mathematical model partitioning probabilistic method random sequencing search techniques tree structures
variable length tree structures minimum average search time suggests paper file organized tree structure search update frequently structure fast search slow update characteristics binary searching slow search fast update characteristics serial searching method restriction terminal nodes level tree paper considers effect restriction trees property set node defined studied proved coding nodes set respect number terminal nodes sufficient minimum average search time general case entire structure tree procedure developed constructing tree minimum average search time simple closed expression minimum average search time obtained function number terminal nodes storage capacity required implement tree structure digital determined finally total cost structure cost criterion computed shown significant improvements average search time total cost obtained restriction terminal nodes level tree information retrieval file searching tree structures double chaining
data display oriented data user oriented data retrieval display command language user easy means data retrieval display requests data displayed tables graphs produced format paper statements request language general design day data display information retrieval graphic display command languages report program generation management data processing
criteria time sharing performance time sharing systems defined article systems permit terminal user essentially full resources sharing time terminal users terminal user ability full resources makes evaluation time sharing systems difficult criteria successfully perform level time sharing performance evaluation january time sharing performance criteria time sharing operation time sharing performance analysis
directed random generation sentences problem producing sentences transformational grammar random generator create phrase structure trees input lexical insertion transformational discussed random generator produce base trees transformations frequently long practical interest solution offered form program user direct generation simple powerful device restricted program directed random generator accepts input restrictions produces tree restrictions phase grammar underlying linguistic model presented aspects theory syntax program written fortran iv ibm part transformational grammar partial grammars english january transformational grammar natural language syntax language processing sentence generation computational linguistics syntax
calculation polynomial derivative values scheme january smith function evaluation polynomial evaluation algol procedure scheme
distribution s14 january field fisher distribution students distribution
finding solution functional equations january functional equations interpolation nonlinear equations method
complete elliptic integrals january special functions complete elliptic integral kind complete elliptic integral kind
student distribution s14 january student distribution test small sample statistics distribution function
role programming ph science program general paper role programming advanced graduate training discussed subject related programming programming considered importance application formalism considered good empirical outline sequence courses included subject obtained extensive programming references included january graduate level programming graduate programs content sequence graduate curriculum programming research topics programming
computing polynomial determinant collins reduced algorithms computing resultant polynomials variables key step computation solving systems polynomial equations elimination studied determining implementation depends extent factors introduced extent propagation errors caused truncation real coefficients memory requirements computing speed preliminary considerations choice determinant collins reduced polynomial sequence detailed tests performed sample problems show determinant superior polynomials case collins reduced faster determinant superior numerical accuracy stability regard round errors results tests reported detail january resultant polynomial resultant elimination determinant determinant reduced multivariate polynomial equations
object code optimization methods analyzing control flow data flow programs compilation applied program improve object time efficiency relationships statements necessarily executed global common expression elimination loop identification implementation fortran january compilers data flow analysis efficiency fortran graph theory loop structure machine instructions object code optimization redundancy elimination register assignment
computers group theory survey computers applied diverse range problems group theory important areas application present enumeration groups finite groups character tables calculus group theory programs range simple combinatorial numerical programs large symbol manipulation systems survey important algorithms results obtained existing programs extensive included january group theory enumeration groups character tables calculus permutation groups groups discrete mathematics numerical programming symbol manipulation survey
assumptions december algol fortran assumptions integer variable range memory finite word size
efficient handling binary data december binary variables variables bit strings cross
estimates distributions random variables communications traffic models study communications characterized distributions underlying elementary model user interactive process model elementary sense random variables generally interest communications studies elements model data examined operational systems model shown variables model distribution independent systems examined shown gamma distribution describe discrete variables approximations gamma distribution exponential distribution discussed systems studied december communications time sharing operating systems optimization models
index subject algorithms december
exponential integral algorithms december fortran standard
eigenvalues eigenvectors real symmetric matrix f2 december real symmetric matrix eigenvalues eigenvectors qr
characteristic values solutions differential equation s22 december differential equation function characteristic periodic solution solution
optimum merging storage displayed yields merge orders total read time defined sum time data transfer time minimized sort storage analysis terms ratio time time takes core records file size units core lengths applied conventional cpu storage combination explicit formula total read time derived terms parameters total read time calculated optimum merge orders formula involves roots simple transcendental equation short table roots included numerical results displayed wide range parameters found read time optimum merging hardware configuration proportional file length times logarithm file length december sorting merging optimum merging storage sort timing drum merging access time
list set generator construct evaluating set expressions list set generator defined algorithms list set generator construct added list processing sets efficiently generates set results expression involving sets set operators efficiency evaluating expression parallel evaluating subexpressions sets final result december set manipulating list processing set generation sets lists file processing
improving round runge kutta computations method runge kutta scheme common based incomplete floating point operations method improved version reduces round error significantly note scheme presented fortran language shown improved version method obtained addition fortran statements version significant improvement numerical comparing included december runge kutta methods ordinary differential equations round error error analysis
interrupt based organization management information systems programming structure language constructs supervisory organization proposed design coding large shared data base systems organization generalized interrupt structure introduced concept file process program structures interrupt generating conditions items data base conflicts arise scheduling interrupt processing routines presented programming language supervisory concepts implemented illustrated organization proposed management information systems december management information systems integrated data processing monitoring systems supervisory systems interrupt scheduling parallel processing
process management resource sharing main design principles emphasis basic ideas underlying design implementation details main features include ability user schedule parallel processes primitive operations file memory relationship allocation scheduling policy takes account recent information user behavior december time sharing multiprogramming process scheduling resource allocation
efficient search find elementary circuits graph efficient search presented search find elementary circuits graph easily modified find elementary circuits attribute length proof application empirical bounds presented relating speed number vertices number speed related number circuits graph give relation speed complexity extensions graphs discussed december graph theory circuit search path search searching
program store functions time program makes storing editing functions time functions typical generated human multiple functions produced long time sufficiently high sampling rates describe fast human functions variety purposes control machine tools program operates small functions stored disk file functions created real time human inputs stored functions computed functions real time feedback process controlled important link environment effective man machine interaction december moore music music real time control digital control time functions interactive software systems program
condition numbers matrices november matrices condition numbers matrices eigenvectors eigenvalues
comment working set model program behavior november demand paging working set paging rate multiprogramming
correction logical arithmetic computers complement binary arithmetic november binary arithmetic arithmetic maximum significance arithmetic full precision arithmetic
generalized method generating argument function values november mapping function decision hierarchy table
improved produce complex a1 november number theory prime numbers complex numbers
eigenvalues eigenvectors real general matrix f1 november eigenvalues eigenvectors roots method qr inverse iteration
increasing efficiency quicksort m1 november van sorting quicksort
magnetic tape information interchange proposed american national standard november input output magnetic tape information interchange measurement phase
recorded magnetic tape information interchange phase proposed american national standard november input output magnetic tape information interchange measurement phase
nonrecursive list simple nonrecursive list structure scheme garbage collector suitable compact lisp list structures presented recursion partial structure built lists november list garbage collection compact list lisp
linear quotient hash code method hash coding presented shown desirable specifically simple efficient time performance data implementation november bell hashing hash code scatter storage calculated address search table symbol table keys
pl source statement accepts pl source program operates produce version logical mode logical structure source program pattern output logic errors logical analysis compilation runs number give user full control output format utility aid early development pl source usage logical unit coding statement case number times executed recorded execution feature expected provide major aid optimization pl programs november smith logical analysis pl source pl source documentation aid execution time usage data
multiple precision division generalized division positive integral presented depending algebraic relationship divisor original divisor performed division operation method quotient equal greater final replacement november multiple precision division
multi attribute retrieval combined paper file organization scheme designed secondary index scheme inverted files secondary key fields redundancy storing keys access numbers records satisfy combinations secondary index values keys input query derived subset fields single access index file combinations values combination required query method case conventional secondary index scheme advantages elimination multiple accesses cases elimination elimination time perform intersection key sets secondary index field long strings keys index field query values redundancy cases secondary indexing method general case number accesses query redundancy exists november file organization secondary index files inverted files information retrieval data management access method secondary keys storage rapid retrieval balanced scheme elimination combining query multi attribute retrieval
interactive display approximation linear programming interactive program graphical display developed approximation data means linear combination functions including splines selected user coefficients approximation determined linear programming minimize error auxiliary conditions approximation interactive examples november approximation data fitting functional approximation linear programming interactive graphical display spline functions
interactive graphics solve numerical problems line time sharing systems graphic terminals dimension numerical problem solving capabilities simply power achieve fast turnaround develop interactive routines easy advantage capabilities human problem line systems general purpose mathematical problem solving implemented special purpose systems solving problems area ordinary differential equations advantage problem area interface user greatly simplified paper discuss advantages systems design considerations interactive routines implementation line squares data fitting program presented results obtained empirical data area future work field discussed october smith interactive graphics graphics graphics squares data fitting interactive computing line mathematics
numerical inversion transforms october transform inversion integral transformations integral equations
efficient sorting minimal storage m1 october sorting minimal storage sorting digital sorting
normal curve integral s15 october normal curve integral probability special functions
modified integration d1 october numerical integration integration romberg quadrature modified romberg quadrature values rectangle values
spanning tree october graph tree spanning tree
date conversion october date calendar
integer programming problem october integer programming change making problem
student s14 october hill student statistic asymptotic approximation
student distribution s14 october hill student statistic distribution function approximation asymptotic expansion
formalism translator interactions formalism presented describing actions processors programming languages compilers interpreters interactions complex systems compiler compilers languages formalism define answer question meta compiler interpretive addition presented produced set component processors october translator compiler interpreter language processor compiler compiler
transition network grammars natural language analysis transition network grammars analysis natural language sentences structure building actions grammar network restructuring copying produce structure representations type obtained transformational analysis conditions powerful rule analyses advantage semantic information parsing advantage model natural language analysis discussed detail illustrated examples implementation experimental parsing transition network grammars briefly october computational linguistics grammars grammar models linguistics natural language analysis parsing semantic interpretation transition network grammars transformational grammars
numerical constants september numerical numerical constants
number generated september automata finite automata generated automata generators length state minimal length generators
comment bell quadratic quotient method hash code searching september hashing hash code scatter storage calculated address clustering search symbol table keys table
regular coulomb wave functions s22 september coulomb wave functions wave functions regular coulomb wave functions
decision table translation september decision table decision table translation
special series summation arbitrary precision c6 september function evaluation series summation approximation
systems september smith characteristic order
increasing efficiency quicksort method presented analysis quicksort average asymptotic number comparisons needed shown log formula derived terms probability distribution bound partition formula simple form generalization considered hoare choice bound random sample main paper generalization quicksort interval single element bound generalization easy implement program numerical approximation shows version quicksort compared original implies number comparisons percent actual tests percent computing time september van sorting quicksort information content distribution
complex matrix inversion real comparison complex matrix real matrix inversion made shown complex inversion fast real inversion rounding error bound complex inversion real gaussian elimination extended product bound half real september complex matrix inversion matrix inversion inversion rounding errors rounding error bound error bounds complex rounding error bounds
optimal starting approximations generating square root slow machine slow division iterative scheme square root classical scheme problem optimal initial considered optimal polynomial initial approximations september square root newton iteration optimal
variation method solution point boundary problems recently published method solution nonlinear equations improved applied give significant variation method solution point boundary problems resulting method numerical solution optimal control problems euler formulation estimates presented variation fast problems context september boundary problems newton method nonlinear equations optimal control optimization ordinary differential equations method solution orthogonal matrices
square roots differential equation difficult numerically points simple september quadrature differential equations
higher level data plotting software extensible software designed make display data simple hardware independent implemented variety diverse configurations elements common types data plots outlined elements combined based simple modules demonstrated modules independently independent systems plot enables plots complexity constructed modules basic syntax outlined description current utility software macros produce plots formal text map plots user minimum information fully user program written conventional higher languages functions layout multiple elements plot handled automatically software user structuring plots multiple independent contained transformation projection entire plots action simple modules user levels construct data characters transformations produce variety effects september graphics data data display syntax hardware independent software display device independent software plot elements plots user interaction organization map display projection
interactive software computers aided design application circuit project characteristics interactive software intended interface designer steps design process presented main emphasis description features high level user oriented languages operating levels interaction based interactive monitor language designed perform control functions software design criteria provide user commands simple efficient order perform functions needed aided circuit design circuit oriented graphic language designed describe generate manipulate graphic problem specifications extension fortran graphic type variables designer familiar fortran learn language application aided circuit design examined hand design criteria provide sufficient extend languages assisted applications september interaction graphics graphics aided design circuit design software software organization language monitor language graphic language extended fortran
procedure generation dimensional half graphics description producing generated half dimensional polygonal surface structures significant increase speed computation developed university implemented science laboratory cdc university history leading development results presented compared runs achieved approach extension procedure variable position september half graphics line scan image processing hidden surface polygonal surface structure
proposed american national standard x3 rectangular row punched august card card information processing
proposed american national standard august state state states united states data elements data codes numeric codes codes
algorithms policy revised august august
gaussian quadrature formulas d1 august jr quadrature gaussian quadrature numerical integration function orthogonal polynomials newton method successive
simpson rule multiple integration d1 august numerical integration multiple integration simpson rule
symmetric polynomials august mckay symmetric polynomials symmetric polynomials
ordered functions s22 august functions ordered functions
binary ordered functions s22 august functions binary ordered functions
function s22 august function
function minimization linear search e4 august function minimization relative minimum newton method
technique generating optimal floyd evans productions precedence grammars technique developed generating optimal floyd evans productions precedence grammar graph formulation problem merging productions productions generated minimum cost inverse graph technique demonstrated precedence grammars defined productions generated precedence grammar modified correct optimal parsers obtained august translator writing systems syntactic analysis floyd evans productions precedence grammars translator optimization minimum cost inverse graph theory
multics array measuring tools aid implementation utility discussed tools include special hardware data general purpose programmed tools specialized measurement facilities measurements interest demand paging multiprogramming detail effectiveness lack individual tools provided august performance measurement multiprogramming systems measuring tools analysis multics event demand paging driven measurement
sorting paging environment sorting study part extensive measurement project experimental paging implemented ibm research order virtual machine concept study concerned implementation sorting procedures context dynamic paging environment characteristic virtual memory machines descriptions experimental sort programs analysis performance measurement results obtained presented experimental effort set guidelines writing sort programs paging environment august sorting merging virtual machines paging systems dynamic storage allocation measurement systems program behavior performance evaluation memory management
full table quadratic searching scatter storage quadratic residue search method hash tables clustering linear search method simple quadratic search accesses half table shown length table prime form integer table accessed quadratic separate access original entry point search method presented computationally simple advantages quadratic search accesses table august day quadratic residue search method hash tables scatter storage dictionary quadratic search searching hashing hash code clustering
normalization techniques hand printed family pattern standardization techniques based projection applied file hand printed obtained principle involves terms convex pattern square amount overlap class characters amount classes evaluate degree normalization achieved respect published methods including size normalization august pattern recognition character recognition normalization transformation central projection hand printed characters linear transformation size normalization mapping pattern
allocation resources pricing answer complex generation computing systems means resources systems user community means suggested frequently pricing procedure paper manner computing resources considered extent pricing mechanism discussed pricing serve mechanism times consideration means order make dynamic allocation resources consideration means users effects price subject pricing attention recently number purpose operation attempt made advantages advantages pricing pricing systems discussed order demonstrate applicability pricing environments august allocation mechanisms pricing flexible pricing pricing priority resource allocation user
comment approaches programming july method proofs programs structure programming
note paging july paging machines demand paging replacement
note data base july data base synchronization deadlock reference count
comments paper july automatic segmentation program
student distribution jacobi polynomials modified romberg quadrature factorial analysis variance algorithms july fortran standards
exponential integral july
bessel functions kind july bessel functions bessel functions order bessel functions
greatest common divisor integers a1 july greatest common divisor number theory equations
exponential integral july exponential integral special functions rational chebyshev approximation
context sensitive parsing paper presents form context sensitive parsing context sensitive analysis amount memory required essentially required store single complete derivation addition modified version basic presented blocks infinite analyses grammars loops compared previous parsers context sensitive grammars general systems difference types analyses discussed appears including space time degree context involved july context sensitive grammars context sensitive parsing formal grammars formal language theory parsing parsing algorithms recognition algorithms
bound greatest common divisor integers version finding greatest common divisor integers presented number arithmetic operations number storage locations linear theorem bound number integers extended case integers construct minimal set presented fortran program appears comm acm july greatest common divisor number theory equations
file structures hashing functions general method file structuring proposed hashing function define tree structure types trees examined relation trees studied past probability distributions path lengths derived illustrated july jr data structures tree structures file structures scatter tables hashing functions information retrieval
space time hash coding errors paper computational factors set messages hash coding methods examined compared conventional hash coding method computational factors considered size hash area space time required identify message set time error frequency methods intended reduce amount space required hash coded information conventional methods reduction space accomplished possibility small errors applications applications large amount data involved core hash area feasible conventional methods applications performance improved smaller core hash area conjunction methods secondary time test small errors methods discussed areas application methods analysis problem allowing small number test messages identified members set permit smaller hash area increasing time july hash coding hash addressing scatter storage searching storage layout retrieval retrieval efficiency storage efficiency
programming level sequence easily implemented flexible provided summarized implementation techniques made running machine man effort discussed approach successful machines widely characteristics july macro processing machine independence programming languages implementation techniques
conversational access word machine line running word full facilities text editing automatic file maintenance program preparation assembly preparation editing displayed character text strings user simply lines working directly features uniform command set user machine small aids program design providing display scope tapes standard items environment similar sophisticated terminal tapes similar disk priority design efficient tape algorithms minimize limitations small memory techniques developed handling editing structure outlined people design strongly performance criteria established users specification period july conversational access display editing display oriented algorithms man machine communication line editing line efficiency line environment editing small machine tape tape oriented text editing
interactive command generating facility facility permit controlled tasks executed environment proposed means programs generate interactive time sharing commands output response presented commands console keyboard argued facility current limitations man communication set functions embedded string processing language suggested information pertinent implementation facility existing time sharing systems july time sharing command languages pseudo interaction conditional job control operating systems
permutations set g6 june permutations combinations permutations
combinations objects g6 june permutations combinations permutations
function square matrix ii g6 june matrix determinant
modified romberg quadrature d1 june numerical integration romberg quadrature modified romberg quadrature values rectangle values
m1 june sorting minimal storage sorting digital sorting
m1 certification form proof correct practical sorting array proved correct june proof algorithms debugging certification sorting place sorting
eigenvalues eigenvectors real symmetric matrix f2 june real symmetric matrix eigenvalues eigenvectors qr
permutations set g6 june permutations combinations permutations
combinations objects g6 june permutations combinations permutations
relational model data large shared data future users large data data organized machine internal representation service information satisfactory solution activities users terminals application programs internal representation data aspects external representation change data representation needed result query update report traffic natural growth types stored information existing data systems provide users tree structured files slightly general network models data section models discussed model based relations normal form data base relations concept form data base relations concept data introduced section operations relations logical inference discussed applied problems redundancy consistency user model june data bank data base data structure data organization hierarchies data networks data relations redundancy consistency composition retrieval language calculus security data
incorporating qr symmetric tridiagonal matrices qr iteration eigenvalues symmetric tridiagonal matrix incorporating sequence shift directly elements matrix incorporated means implicit methods direct method small eigenvalues implicit method effectively shift convergence paper presents method june eigenvalues eigenvectors qr method symmetric tridiagonal matrix
comparison adaptive newton quadrature routines evaluating definite integrals report compares performance adaptive quadrature schemes based newton 2n point rules approximating set definite integrals integral relative accuracy june adaptive newton quadrature quadrature scheme comparison definite integral evaluation adaptive numerical newton integration integration quadrature efficiently plot rules applications newton rules modifications
accurate floating point summation paper describes method set floating point numbers comparison error bound method standard summation method shows considerably sensitive propagation round error june summation floating point addition round error round propagation
automatic parsing content analysis automatic syntactic semantic analysis natural language text applications content analysis requirement preliminary studies show syntactic analyzer produce correct identification subject object approximately half relevant occurrences degree content analysis variables compares manual methods variables compares manual methods sample total text processed june content analysis parsing syntactic analysis natural language processing information retrieval language analysis text processing
pl program assist comparative practical pl program assist comparative determine regular related languages data input pairs program list processing techniques sort count pair words assigned relative function total frequency data correspondence found pair words output list correspondence types frequency data separate correspondence word pairs showing correspondence relative chosen point article usefulness limitations programs small portion data june comparative linguistics natural language processing comparative method linguistics linguistics relationship change correspondence regular correspondence list processing
scheduling reduce conflict conflicts scheduling defining linear graph independently relation activities conflict additional constraints time space connected component graph found gotlieb set events times june allocation conflict matrix connected component scheduling spanning tree linear graph
conversion decision tables programs execution time ambiguities decision tables discussed pointed attempt ambiguities compile time general shown tree methods converting decision tables programs regard ambiguity detection algorithms programming decision tables simplicity implementation detection ambiguities execution time presented limited entry decision tables importance proper coding information decision table programs mixed entry decision table directly intermediate step conversion limited entry form resulting storage economy comparison algorithms proposed literature made features decision table fortran iv translator ibm developed authors june decision tables diagnostic aids analysis business applications
feasibility input line processing line digital processing considered ordinary telephone complete terminal device input provided sequence words output user machine feasibility implementing fortran algebraic compiler object processor considered details specific word recognition program technique depends restrictions small vocabulary set input word experimental results presented error rates experimental conditions machine resources required users time results show time feasible handle users time ibm june speech recognition word recognition pattern matching pattern recognition time sharing remote access input speech input telephone input output signal word input computers man machine interaction
subroutine perform transposition rectangular matrix rectangular matrix
linear programming integer variables dual method
random vectors uniform solid angle g5 random number random vector random number generator probability distribution frequency distribution simulation monte carlo
transposition rectangular matrix f1 rectangular matrix
language graphs language representation graph formulation graph operations node link deletion insertion union intersection comparison graphs graphs represented linked lists language defined extension algol algol means syntax driven compiler application areas language operation research network problems control theory traffic problems graphs oriented multiple graph language extended algol operator precedence syntax driven compiler operation research network traffic
simple language based principle reference concept experimental programming language characteristics permitted context language context functions results functions values variables assignment addressing introducing values called reference values assignment operation relation reference data structures functions type declarations permitted functional approach data structures references process accepts data structure equivalent structure internal representation generally data structure implicit arbitrary computing components existence variables permits construction coroutines parallel processes control mechanisms variety programming examples language limitations extensions discussed briefly programming language data structure reference assignment parallel process language language lambda calculus list processing nondeterministic
construction bounded context parsers accepts arbitrary context free grammar constructs bounded context parser parser exists part paper definition context free grammar working bounded context parser notion reduction class context free grammar introduced connection structure bounded context parser pushdown automata generate reduction classes context free grammar defined finally essentially study runs pushdown automata generating reduction classes part utility discuss light experience compiler design simultaneous design language compiler bounded context parsing bounded context syntactic analysis parser construction analyzer construction generators compiler compilers compiler writing systems translator writing systems context free grammars formal languages pushdown automata
application sequential sampling simulation model sequential sampling procedures applied analysis data generated simulation experiment multi item model procedure cost time required achieve levels statistical precision calculated cost time comparable fixed sample size methods calculated costs fixed sample size procedures sequential sampling procedures compared graham simulation models sequential sampling models experimental design
translation equations
operations generalized arrays compiler operations vectors matrices higher dimensional storage arrays standard features compilers today elements structures restricted sophisticated applications restriction data representations efficient implemented elements multidimensional arrays multidimensional arrays developed storage structure location length content array code words describe arrays providing needed descriptive information form multidimensional arrays matrix operations storage control compilers
programming line analysis images preliminary description software display special emphasis man machine interaction intended wide variety applications methods applied programming tasks picture transformations file maintenance picture structuring display management picture structuring considered vehicle man machine communication data format pictures called picture form developed structure operators defined manipulate picture forms produce pictures forms ideas symbolic mathematical laboratory image processing image processing line image processing image processing data structure structure operators picture processing picture processing line picture processing picture processing list processing picture processing
algol construction procedures parameters procedures april algol procedures parameters side effects
comment multilevel boolean minimization april multilevel logic design generalized prime minimal forms minimization functions
comment multiprogramming page demand strategy april smith multiprogramming paging modeling
comments paper april jr page demand demand paging time sharing multiprogramming models scheduling strategies operating systems memory management
formal information retrieval files april
filon quadrature d1 april quadrature filon quadrature integration filon integration fourier coefficients fourier series
modified romberg quadrature d1 april numerical integration romberg quadrature values rectangle values error bound
solution linear programs variables implicit enumeration april linear programming variables partial enumeration
d1 april numerical integration integration rule adaptive integration automatic integration simpson rule numerical quadrature quadrature quadrature rule adaptive quadrature automatic quadrature round error control
newton method solving simultaneous nonlinear equations april newton method nonlinear equations polynomials
cubic splines uniform simple procedure presented constructing cubic splines periodic uniform construct basis splines requires minimal storage computation permits easy april simple spline representation splines uniform splines
problem problem presented simulated results issues reported april jr simulation
representations space planning problems involving arrangement objects space objective function primarily consists derivatives distance objects arrangement called space planning problems requirements problem area defined compared current graphic languages alternative data structures automated space planning compared april automated design data structures graphics aided design engineering design design
multiprogramming machine coding organization april wirth
multiprogramming paper describes philosophy structure multiprogramming extended hierarchy operating systems diverse requirements program scheduling resource allocation environment program execution input output handled parallel process es fundamental set primitives dynamic creation control hierarchy processes communication april multiprogramming operating systems parallel processes process concept process communication message process hierarchy process creation process removal
complete matrices matrix calculus introduced developing data structures suitable high level algorithmic language mathematical programming paper special structure matrices utilized efficient computing memory space operations sequences matrices sequences sequences matrices considered matrix operators sequence operators operators algorithms symbol manipulation matrix expressions find forms suited computation forms called normal forms results obtained sense expression equivalent expression normal form found calculus april complete calculus data structures linear programming matrix matrix matrix sequences programming languages sequence operations symbol manipulation
syntax directed documentation pl language pl phrase structure grammar basis idea called syntax directed documentation idea phrase structure program define structure formal documentation program syntactic types resulting structure automatic questions programmer part documentation provide automatic storage retrieval facilities programmers program access resulting documentation cross ways syntactic types objects small pl program found literature april documentation syntax analysis pl documentation documentation automatic phase structured grammar syntax directed documentation syntax processing
creation control internal data fortran programming environment method definition user common structure automatic generation common dimension equivalence type declarations user routines definition common contained easy form allowing control general communications data routines implemented ibm cdc series ibm method proved definition control common large scale programs april data base fortran common common subroutine communication data communication
note complement context free languages ambiguity inherent ambiguity complement context free language language phrase structure language production type language bounded language
comment paging paging machines demand paging replacement
method converting decimal binary decimal conversion arithmetic
number permutations permutation ordering number number number combinatorial
network linear programming minimum cost flow network flow
prime number a1 prime numbers generator
symbolic expansion algebraic expressions algebra symbolic algebra symbolic multiplication algebraic distribution algebraic multiplication distribution multiplication product polynomial distribution polynomial expansion
language partial differential equations conventional methods solve continuous problems characterized partial differential equations time convenient easy learn high level problem oriented language solve study partial differential equation problems designed practical translator language designed working version constructed significant portion language partial differential equation language outlined translator briefly summarized problem oriented digital simulation language partial differential equations translator pl pl finite difference algorithms
question answer natural language inference question answering aspects iii language processing detail written lisp operates time sharing data structures semantic organization question answering formalism relational properties complex relation operators question answering procedures features operation illustrated examples performance limitations question answering capability presented discussed shown semantic information question answering greatly process top procedure question answer enables effective made information concluded development iii work large data require data structures algorithms question answering question answering natural language iii lisp semantics artificial intelligence computational linguistics language processing fact retrieval
comparison error improvement estimates adaptive integration simple error improvement estimates rule studied demonstrate comparison procedure independent adaptive search strategies comparisons based inclusion makes usual polynomial based comparison behavior found factor estimate based constant assumption differences considered slightly considered adaptive integration error improvement estimate rule error criteria
nonlinear minimax approximation nonlinear minimax approximation problems properties permit application special algorithms based algorithms solution paper application problems type general nonlinear due considered examples illustrate give satisfactory results successfully solve problems lead difficulties conventional method minimax approximation nonlinear approximation linear programming
measurements segment size distributions segment sizes measured routine operating variable segments discussed feature measurements large number small segments percent segments words results independent features algol relevant design systems respect organization paging schemes storage allocation segmentation segment sizes page sizes paging resource allocation memory allocation core utilization
experiments tree searching program procedure improvement backing procedure widely program game purposes based principle desirable making decisions procedure node node procedure node function procedure written lisp game demonstrated procedure significantly superior procedure statistical significance important conclusions information statistical significance papers experiments artificial intelligence field experiments serve model future work artificial intelligence heuristic program tree searching lisp game decision theory backing procedure backing procedures
program programming developed ease cost improve results elementary instruction programming student experience conversational language designed teaching minimal term experience discussed appears successful straightforward make successful similar programs tutorial results extended research research elementary programming assisted learning
test probabilities student distribution hill test student statistic distribution function approximation
eigenvalues vectors real general matrix characteristic equation matrix matrix
approximation
squares fit e2 nonlinear squares fit
fitting data exponential e2 nonlinear squares fit
restricted partition generator a1 partitions restricted partitions sums integers restricted sums
number restricted partitions a1 partitions restricted partitions sums integers restricted sums
interactive graphical flowchart input interactive operational graphical terminal designed demonstrate method programming interpretation flowchart user description data description large scale design simulated graphic representation processed signal scope successful design require modifications original design graphical interactive environment perform iterative process efficiently effectively simulation program graphical input output data systems
education graduate school management years experience design evaluation management information systems requires understanding related technology concepts paging priority interrupt systems explained machine language level machine criteria issues effort solution interesting problems capable issues significance capable issues significance chosen machine issues great depth equipment provided provide student diagnostic aids great depth student access machine capable extension issues constructed simulated machine software criteria called reference manual education simulation machine language management information systems interpreters
quadratic quotient method hash code secondary clustering secondary clustering hash code discussed hashing method based elimination presented comparisons previous methods made bell hashing hash code scatter storage calculated address clustering search symbol table keys table
variation sorting address calculation principles address calculation merging combined yield efficient sorting technique detailed flowcharts important program steps included characteristics proposed sort discussed sorting address calculation merging order sequence creation
quadratic residue research quadratic residue search method previously suggested avoid clustering encountered hash address occur linear search methods search size property quadratic limited half storage table shown classes prime numbers complement set quadratic easily determined entire table size prime number quadratic residue search method hash addressing address clustering scatter storage file searching file addressing hash coding quadratic search random search storage layout searching
efficient context free parsing parsing efficient general context free similar knuth lr familiar top time bound proportional length string general bound grammars runs linear time large class grammars include practical context free programming language grammars empirical comparison appears superior top bottom algorithms studied syntax analysis parsing context free grammar compilers computational complexity
spelling correction systems programs specialized techniques shown efficiently incorporating spelling correction algorithms compilers operating systems include syntax semantics information organization restricted symbol tables consideration limited class spelling errors sample coding performing spelling correction presented systems perform spelling correction number debugging runs program programmer machine time spelling correction error correction debugging compilers operating systems error detection lexical analysis systems programming
translation equations input limited expressions translation equations describe syntax left context sensitive semantics context free languages formal procedure set translation equations specifications pushdown translator translator consists form finite state automata means pushdown stack framework string recognition parsing special cases translation problem automata turing machines regular expression expression context free languages translation parsing meta compilers pushdown syntax directed compilers finite state automata
parser hierarchical syntactic structures syntactic parser hierarchical patterns presented analyzer form linear strings emphasis significant addresses means processing times large scale matching procedures substantially reduced description makes examples fully operational implementation parser experimental english sentence analyzer structuring area central core storage individual locations bits represent data involved matching procedure information reduced minimum searching lists eliminated means binary state single bits determines operational flow procedure method implemented interpretive grammar provided expressed functional classification items input hierarchical structures parsing syntactic analysis natural language analysis linguistic data processing computational linguistics grammar structure recognition pattern recognition matching procedures tree structure interpretation machine translation automatic
formal information retrieval files generalized file structure provided concepts index record file directory file structure directory record retrieval defined frequently file structures inverted files index sequential files files derived algorithms records generalized file structure presented attribute pair index record record address list file directory generalized file structure inverted file index sequential file file description file search directory search serial processing lists prime parallel processing lists
fortran pseudorandom number generator january random numbers pseudorandom numbers shift register sequences
interchange tape information interchange proposed american national standard january interchange tape tape information interchange tape paper tape dimensions
representation date machine machine data interchange proposed american national standard january calendar date machine machine interchange day representation coded
efficient sorting minimal storage m1 january sorting minimal storage sorting digital sorting
derivatives s22 january gautschi recursive computation successive derivatives error control
produce complex a1 january complex numbers
partitions natural order a1 january mckay partitions number theory
general random number generator g5 january random number generator probability density function transformation density function
generator random numbers poisson distribution g5 january poisson distribution random number generator
numerical inversion transforms january transform inversion integral transformations integral equations
note minimal length polygonal approximation contour method smooth polygonal contour image illustrated ordered sequence contour points connection graph image obtained modified image scan minimal polygon constraints chosen approximating contour determination minimal polygon reduced nonlinear programming problem solved takes account variables examples presented computing times january image connection tree minimal polygon optimal approximation nonlinear programming
experience extensible language operational extensible language base language respect efficiency flexibility utility users january programming languages extensible compiler ambiguity
natural language question answering systems recent experiments programming natural language question answering systems reviewed methods developed syntactic semantic logical analysis english strings concluded effective techniques answering questions natural language subsets small scale experimental systems research field current approaches semantic analysis logical inference effective respect aspects meaning applications large subsets english current small scale experiments language processing systems based entries large grammars semantic systems order complexity require development approaches semantic analysis questions answering january question answering natural language artificial intelligence language processing fact retrieval semantics
processor allocation method time sharing scheduling proposed intended minimize tasks processors reduce head application general resource allocation problems implemented means method efficiently handling changing lists january time sharing resource allocation scheduling algorithms monitors dynamic allocation processor allocation multiprogramming multiprocessing time scheduling conversational systems interactive systems
recursive computation derivatives study error propagation study made propagation errors linear order difference equations recursive computation successive derivatives considered january gautschi recursive computation successive derivatives error propagation
automatic segmentation cyclic program structures based processor timing time shared multiprogrammed batch systems frequently require segmentation programs discrete program storage segmentation program manner reduces frequency subject paper segmentation techniques proposed subject limitations arise segment size compatible physical restrictions computing equipment generalization suggestions made order application january automatic segmentation cyclic program structures loops paging multiprogramming compilers time sharing program
rapid computation quadrature rules d1 december divided differences
rapid computation coefficients interpolation formulas december divided differences newton interpolation formula
assignment problem rectangular matrices december operations research optimization theory assignment problem rectangular matrices
extension assignment problem rectangular matrices assignment problem proposed solution square matrices presented authors develop extension permits solution rectangular matrices timing results obtained version algol procedure discussed relation solution time problem size december operations research optimization theory assignment problem rectangular matrices
rapid computation general interpolation formulas mechanical quadrature rules continuous closed interval linear functional attempt made approximate polynomial approximating algorithms developed rapid computation wide class includes rules special cases december linear divided differences newton interpolation formula
note modification method step point december ordinary differential equations multi step methods round error method modification
lisp techniques paging environment employs block concept global local variables addition methods applied lisp systems means list representation local sequential lists created compilation block level sequential created garbage collection introduced make lists compact partial garbage collection performed block total garbage collection storage procedure combination features eliminated free list effectively minimizes number pages december lisp list processing paging virtual memory garbage collection core fragmentation compact list structures block segment
language systems programming language language designed suitable writing production software systems specific machine pdp compilers operating systems prime design goals design ability produce highly efficient object code access relevant hardware features machine provide rational means nature systems programs major feature goals mechanism definition representation data structures terms access elements structure december programming languages implementation language systems programming data structures
implementation test hashing technique implementing test determines string low probability test satisfied shown operation considerably test chosen hash codes strings december hashing subset information compression information retrieval searching
retrieval update speed combined paper november communications acm introduced technique file indexing combined technique permitted retrieval time cost increased storage space paper examines combined conditions file usage retrieval update curves developed show minimal cost file usage partially combined december file organization combined index files inverted files information retrieval query multi attribute retrieval file update
algorithmic selection method map data strings methods map data illustrated generated encoding data strings sequence codes methods directions relationships developed compression alternatives avoid comparing technique data resource maps widely applicable map data reduction december data compression map storage information retrieval input output run coding data reduction
reconstruction pictures projections situations natural sciences ray desirable estimate gray levels digital picture individual points sums gray levels lines projections situations picture determined problem find picture algorithms monte carlo methods designed solve problem algorithms applicable large number fields important reconstruction possibly dimensional ray analysis december approximation image processing efficient encoding image processing linear programming mathematical programming monte carlo techniques optimization picture compression picture description picture processing ray analysis
chebyshev approximation continuous functions chebyshev functions e2 november smith approximation chebyshev approximation
accurate floating point summation floating point sums considered digit base floating point addition range accurately digit floating point numbers numbers parts digit floating point numbers added auxiliary digit finally added yield computed sum digit floating point performed usual conditions relative error computed sum additional digit computed sum full digit accuracy ibm typical values case november floating point summation error analysis
pattern layout heuristic pattern layout program application program developed error important design printed circuit design stage step production logical design design patterns circuit dual line packages discrete components employs methods heuristic method human approaches design interesting time method running based percent required heuristic path respect performance function point point point line connection number successful percent november heuristic pattern layout design printed circuit running
optimizing polyphase sort algorithms polyphase sorting procedure optimum based minimizing total number unit strings read displayed logic complicated algorithms straightforward logic presented simple algorithms discussed approximately fourth half percent writing algorithms today additional fourth percent improvement achieved modified optimum straightforward requires estimate total number unit strings november sorting polyphase sorting algorithms optimum operator
computers higher education past recommendations status data survey conducted national science support published december reviewed pointed regard computers higher education national goals stated reports quality hardware courses half degree programs data processing science offered made studies status goals computing higher education improvement degree programs national testing laboratory educational technology november higher education computers degree programs national goals testing laboratory educational technology
composition semantics algol main features algol explained semantic point view shown language permits composition values actions programs minimum set primitives fundamental recursive rules composition syntax briefly reviewed attempt made obtain structured simple introduction algol orthogonal design november programming primitives programming languages algol semantics recursive composition design programming languages data structures
evaluation taylor coefficients analytic function october taylor coefficients taylor series integral numerical integration numerical differentiation interpolation complex variable complex arithmetic fast fourier transform
concurrent control readers writers problem mutual exclusion independent processes simultaneous access critical section discussed case distinct classes processes readers writers readers share section writers access solutions presented case minimum readers case writing place early october mutual exclusion critical section shared access resources
user program measurement time shared environment general discussion measurement software systems description hardware software scheme measuring user programs time shared environment laboratory implementation characteristics implementation reported showing presented finally shown time sharing systems provide similar measuring facilities october operating systems multiprogramming systems time sharing systems software measurement user program measurement measurement technology virtual computers performance improvement
display procedures structured display files interactive graphics structures present number problems usefulness paper discusses problems suggests alternative approach display design structured display files technique employs display procedures generate information display including transformations calls procedures simplify specification pictures speed generation display procedures permit picture elements defined facilitate processing inputs devices paper illustrated examples euler language display procedures implemented october graphics programming languages display files
experiments automated numerical methods developed university undergraduate numerical methods unit divided modes instruction student controlled presentation student controlled investigation designed independent study students conventional instruction initial measures effectiveness student operational cost result testing independent operational cdc terminals october assisted instruction numerical methods systems
fortran standards report years effort fortran programming language united states initial study application standard specifications maintenance standards result work initial set interpretations prepared published communications acm work continued preparation set interpretations nature maintenance set interpretations standard specifications reported october american national standard fortran basic fortran programming language standardization language standard specification language standard maintenance language standard language standard interpretation standardization committee
understanding data structures paper presents notation formalism describing semantics data structures based directed graphs edges transformations graphs addition implementation facility part programming language programmer expressed semantics terms graphs implementation data structures order efficiency october data structures graph implementation semantic formalism programming language
comment list september lisp garbage collector virtual memory list processing storage allocation
average binary search length ordered lists september searching binary searching record retrieval
criterion newton method implicit integration algorithms nonlinear systems ordinary differential equations september ordinary differential equations linear formulas newton method criterion
note sided approximations september approximation sided approximation logarithmic error relative error
structure attribute based file organization file structure attribute based retrieval proposed paper queries involving arbitrary boolean functions attribute pairs processed lists structure highly dependent file determined specification allowed queries structure retrieval basis values attribute retrieval basis single permitted file organization proposed based boolean algebra generated queries desirable properties structure proved file maintenance questions discussed september address calculation boolean algebra boolean functions boolean queries file organization information retrieval inverted file key words queries
blocks graph corrigendum september
efficient bit table technique dynamic storage allocation word blocks efficient bit table technique dynamic storage allocation word blocks requires minimized amount memory purposes technique tested implementation list processing language number ideas incorporated processor september bit table dynamic storage allocation buddy list processing free storage
education related computers organizations acm curriculum committee education management study curriculum development management information systems education colleges universities national science position paper framework study preliminary conclusions presented education information systems curricula courses suggested role professional organizations computers discussed committee outlined initial approach committee describe education effective computers organizations positions education required survey educational programs september education information analysis systems design business data processing
symbolic integration approaches symbolic integration artificial intelligence large degree algebraic manipulation implementation rational functions mathematics proof problem class functions decision procedure elementary class special functions programs solving differential equations finding definite integral august integration symbolic integration definite integrals rational functions
general application algebraic systems paper describes applications symbolic algebra systems problems general including derivation field equations classification solution field equations simple case attention drawn algebraic difficulties encountered work august symbolic mathematics mathematics general algebraic manipulation equation manipulation
automated algebraic manipulation paper applications automated algebraic manipulation made attention poisson series typical problem theory requirements processors considered compared general manipulation packages future directions research systems briefly outlined illustrate relative simplicity required typical integration problem considered august series manipulation automated algebra
algebraic simplification algebraic simplification examined point view user large expression point view designer construct efficient describe techniques substitution techniques expression make user approaches design automatic simplification capabilities algebraic manipulation systems divided types type facilities manipulation simplification expressions finally discuss theoretical results related algebraic simplification describe positive results existence powerful simplification algorithms number results algorithms classes expressions included august algebraic manipulation algebraic simplification simplification
list systems allowing multiple cell types list processing systems allowed single size configuration list cell paper sizes configurations list cells possibly run time august list processing storage allocation lisp slip based storage pointers
rational function manipulation survey complete symbolic computation rational functions variables integer coefficients designed implemented handle large problems ease efficiency considerable effort minimum amount machine implementation easily variety computing machines paper description language run time data structures implementation august jr symbolic algebra rational function manipulation polynomial manipulation interpreters
applications symbol manipulation theoretical physics paper applications symbolic computation techniques problems theoretical physics emphasis applications activity august symbol manipulation algebraic simplification computational physics
solution simultaneous nonlinear equations july nonlinear equations
graph plotter july plot graph line plot
procedures stable problem july assignment problems assignment procedures discrete mathematics operations research stable problem university
stable problem original work assignment method stable criterion extended find stable derived finding stable proved satisfy conditions problem paper july assignment problems assignment procedures discrete mathematics operational research stable problem university
ordering execution arithmetic expressions arithmetic expression component subexpressions depending hardware environment expression executed subexpressions evaluated parallel combination modes paper shows expression execution time minimized consideration ordering subexpressions subexpressions executed order memory processor time requirements valid configurations main memory multiprocessor buffer memory number subexpressions executed parallel number processors execution subexpressions procedure requirement earlier ordering considerations provide optimal execution sequence july parallel processing arithmetic expressions ordering computational trees compilers
buffer allocation merge sorting fixed buffer allocation merge sorting presented minimizes number input output operations order merge sorting number equal number input output operations time sort time standard terminology introduced input buffer allocation method analysis improvement expected conventional allocation analysis makes distribution function analysis completely distribution yields similar results suggests results distribution function optimum output buffer size determined concluded allocation significantly reduce time merge sorting input data random output buffer allocation data random july file item string merge sort time gamma distribution function
blocks graph efficient method presented finding blocks arbitrary graph graph represented ordered list edges ii matrix word length machine employed storage machine words required graph nodes edges increases essentially case case ii spanning tree edges edges finally blocks representations time required graph nodes increases depends type graph bounds values derived suitable test graphs generated extension grammar approach compared detail proposed read july block block tree fundamental cycle set graph decomposition graph spanning tree grammar
language extension graph processing formal semantics simple programming language extension processing directed graphs defined consists type directed graph data structure set primitive operations manipulating structures easily implemented language emphasis method definition commonly definition language involves definition syntactic elements meaning assigned semantics definition terms semantics data structures operations defined assignment syntactic representation language implemented assignment explicit syntax implementation embedded lisp advantages definition language terms semantics discussed july graph processing programming language formal semantics directed graph lisp network data structure flowchart syntax language definition
simple lr grammars class context free grammars called simple lr grammars defined class shown include precedence simple precedence grammars proper subsets construct parsers grammars shown parser construction techniques cover lr grammars knuth implemented direct comparison proved superior precedence techniques range grammars speed parser construction size speed resulting parsers july context free grammar lr grammar precedence grammar syntactic analysis parsing parser finite state machine deterministic pushdown
programmer training project project purpose selected area programming jobs field organization curriculum discussed july programmer training job fortran
state oriented curricula business acm committee education management national science established state develop series recommendations improving education management provide committee material study united states cross section considered state curricula business topics curricula general related material required functional courses curricula students based information systems analysis common set similar economic issues presentation summary consideration resource allocation issues involved preliminary committee recommendations improving education management report prepared provide institutions background information task development ten man committee university july university programs management education curriculum design business administration curricula graduate business school resource planning
interrupt driven programming july monitors debugging parallel processing associative memories microprogramming
binary summation july summation binary summation floating point addition round errors
meaning names programming systems assumed similarity function data names programming language file names operating functions discussed terms basic concepts order identify extent overlap suggested similarity idea file directory object type context contexts discussed length noted simple extension lambda notation deals ideas context manipulation function abstraction based terms expression lambda list expression list found context viewed abstraction based terms equivalent expression list list expression july file operating programming language functions names context file directory file dictionary lambda calculus theory programming
note compiling fixed point binary developed compiling sequence fixed point binary involving constant significant characteristics simplicity test determines applied degree suggests efficient object code june compiling fixed point arithmetic
numerical properties optimal control paper applied solution state problem represents modification direct method designed improve speed solution storage requirements point real time implementation feasible modification shown stable computationally traditional approach paper describe properties valid numerical technique properties condition established method part paper comparison techniques standard procedure numerically matrix equation determine feedback matrix technique shown significantly faster comparable accuracy june jr johnson splines problem control theory numerical analysis
science conceptual framework curriculum planning science considered global view attempts characteristics field relationships fields local view structure field structure presented terms kinds knowledge problems activities exist discipline relations approach curriculum planning science presented structure field fact change important feature situation science increase working june science curriculum planning education
approach optimum design graphics systems display designers difficult task selecting major chosen large numbers alternatives selection based considerations response time cost distribution data storage processing graphics processor data processing work reported objective design procedure give understanding display systems accomplished means mathematical model driven graphics parameters model functions capabilities graphics hardware computational requirements graphics application model analyzed numerical queueing analysis simulation obtain average response time combining model optimization graphics configuration subject cost found applications optimum configurations find general display design guidelines june design guidelines graphic display systems mathematical model optimum design queueing model
generation permutations expressed circuits systematic generation specific class permutations fundamental scheduling problems complete graph vertices circuits equivalent specific permutations elements permutations defined circular permutations image generated number sets edges set edges determined constructing circuit vertices circuit vertices starting circuit vertices basic operation consists transposition pair vertices position pair permutation determined algorithms vertices presented easy derive permutations permutations permutations reverse order procedures performed efficiently june permutation graph theory scheduling combinatorial algebra
function minimization
partial sorting m1 sorting partial sorting order statistics
recursion induction principle inductive method proving things defined functions shown proving partial functions equivalent applicable proofs interpreters programming languages morris jr recursion induction correctness proofs compiler correctness
implementation variables variables mode implemented technique programming errors calendar recently implementation variables technique programming errors variety compiler interpreter transfer
addresses short presented minimizing sum lengths blocks coding produced compiler length instruction assumed long short long memory location distance current location short blocks instructions computers permit bit addressing relative location full bit addressing memory compiling blocks instructions mutual references simple iterative procedure addresses short paper wide class problems type formulated problems means elementary arithmetic operations column vectors matrix addressing problem integer programming variable length addressing
optimal detection curves pictures technique systems lines presented technique heuristic problem embedded recognition expressed figure merit decision process input picture optimal lines figure merit due global approach greater flexibility problem achieved relation structure figure merit complexity optimization process discussed method suitable parallel processing operations relative state computed parallel number equal length curves log2 approximate method picture processing picture recognition picture description curve detection line detection edge detection optimal detection heuristic methods global recognition parallel processing dynamic programming interaction graph secondary optimization problem
man machine approach solving problem problem important class scheduling routing problems solving distribution problem mathematical methods special forms problem problems number points solved large time heuristic procedures proposed tested slightly results paper describes aided heuristic technique amount time real time solve large point problems technique takes advantage human problem solving solve problem today heuristics data human human solve problem easily technique paper point directions field man machine interaction field artificial intelligence heuristic procedures aided heuristic technique man machine interaction artificial intelligence assignment problem mask assignment generator interaction process problem
merit computing networks suggested means computing capabilities institutions higher learning construction computing networks network constructed area university paper reports operation network past years major impact network power computing capability development central facility sharing ideas important quality variety services provided central facility found key role effectiveness network network power sharing utility networks curriculum development educational computing network computing computing networks remote computing shared computing
introduction feature analysis generalized data base management systems paper separately published introduction main report features generalized data base management systems introduction current state systems discusses differences capabilities found language systems found contained systems discussion problems data independence binding user levels identified technical problems future designers handling existing stored data providing complex data structures conventional programming languages problem high level update functions network structures mentioned discussion problem high volume terminals users level user cobol basis development work considered length respect data structures language capabilities contained capabilities section effect data base task group proposals final section ten major topics main full report systems committee data base management systems programming languages data structures storage structures information retrieval transaction processing
sparse matrix package part f4 april matrix sparse matrix matrix manipulation
complement division division theorem expressed form permits serve basis division operations produce quotient complement form algorithms division complement results derived numbers represented base greater radix radix schemes considered binary form algorithms includes complement implementation problem quotient overflow complement results selecting form condition complement division april division complement arithmetic complement division complement arithmetic complement arithmetic
line dimensional designed inherent conventional input terminal making allowing error design picture sequences conversational mode input elements light user request record ibm instructions produce sequence pictures generated primary facility produce april iii jr graphics line systems dimensional languages
dynamic microprogramming processor organization programming processor characterized small bit word read write storage access time storage similar cycle time machine data subroutines instructions processor conventional perform combinatorial operations sequencing control read write permits flexible assignment resources read storage processor developed paper simultaneous operation testing facilities processor language developed overhead involved subroutine analyzed efficiency flexible software linkage scheme examined overhead subroutine characteristics finally examples problem oriented programming considered resulting coding compared assembly language version technology april microprogramming read write subroutine linkage execution speed
key address transform techniques fundamental performance study large existing files results study key address transformation methods applied set existing files presented method applied file load factor size wide range addition variables pertinent specific method values performance method summarized terms number accesses required record number overflow records created transformation method discussed practical guidelines obtained results stated finally proposal fundamental study outlined april hashing hashing techniques hashing methods hash coding keys key transformation key address transformation direct addressing direct access method random access file addressing file organizations file structures scatter storage search information retrieval
program development activity programming coding examples techniques considered sequence design decisions decomposition tasks data data structures process successive specifications illustrated short number conclusions drawn instruction programming april wirth education programming programming techniques program construction
solution ordinary differential equations differential equations differential equations
exact solution linear equations residue arithmetic f4 residue arithmetic symmetric residue mixed radix representation symmetric mixed radix representation mixed radix conversion prime number linear equations gaussian elimination matrix inversion determinant matrix condition
automatic integration ordinary differential equations integration technique automatic solution initial problem set ordinary differential equations criterion selection order approximation proposed objective criterion increase step size reduce solution time permits solution differential equations program techniques discussed appears differential equations equations integration step control order control
storage utilization memory hierarchy storage assignment performed hashing utilization storage studied level memory hierarchy storage level fast store divided number storage areas entry hierarchy hashing attempt place entry areas area full entry level store areas level store space entries entire hierarchy expression derived expected number entries level expression measure effectively level store means examples storage utilization studied function hashing number storage areas level store divided total size level store williams hashing algorithms memory allocation memory hierarchy memory utilization storage allocation storage hierarchy storage utilization
scheduling assisted paper presents scheduling assisted university notation defined logic implement educational policy results term implementation presented assisted scheduling timetable
automatic program synthesis elementary outline theorem proving approach automatic program synthesis technical details method illustrated automatic construction recursive iterative programs operating natural numbers lists trees order construct program specifications theorem specifications proved desired program proof technique applied transform defined functions iterative programs frequently major order construct program loops recursion principle mathematical induction applied relation version induction rule form program constructed detail artificial intelligence answer extraction automatic program synthesis mathematical induction principle problem solving theorem proving
display graphics display successfully implemented image stored core memory software scan conversion convert rectangular point word bit output display array core storage results free displays large data fast graphical interaction image size points displayed frame rate graphics display scan conversion raster displays
distribution fisher distribution student distribution
roots matrix generalized problem f2 eigenvalues matrix roots roots
complex interval arithmetic complex interval arithmetic defined real interval arithmetic complex interval division defined resulting intervals real intervals real interval arithmetic complex intervals complex interval arithmetic
application game tree searching techniques sequential pattern recognition sequential pattern recognition procedure test features pattern feature tested result test procedure pattern feature tested diagnosis paper authors suggest viewed game nature powerful techniques developed searching game trees easily incorporated directly procedures average backing procedure gamma procedure minimax backing procedure procedure simulated experiments character recognition presented results approach sequential pattern recognition game tree searching game nature gamma procedure average backing procedure dynamic programming bound approach optimal solution
probability distribution values binary trees integral equation derived generating function binary tree values values sorting effort analysis distributed applicable family sorting algorithms discussed hoare singleton van solution integral equation advanced algorithms family makes expected sorting effort substantially reduces variance sorting effort statistical tests values trees points distribution function satisfactory computed generating function empirical tests analytical results previously published results cases uniform distribution ratio case uniform distribution ratio jr binary trees sorting statistical analysis
experiments automatic learning heuristic program automatic learning capability developed implemented multiple program heuristic tree searching program applied resolution theorem proving calculus multiple proving program evaluation functions search proof goal general features calculus created automatic learning evaluation functions multiple regression program produce optimal coefficients linear polynomial functions terms features automatic data handling routines written data learning program proving program analyzing results data generally learning regression analysis experience number experiments performed test effectiveness learning program results learning produced improvements solutions problems collection learning data learning shown successfully domains data collection experiment demonstrated learning program simultaneously improve performance problems specific problems variety domains variations learning program tested learning theorem providing heuristic automatic learning tree searching artificial intelligence problem solving adaptive lisp multiple regression resolution
analysis time sharing techniques effectiveness time sharing techniques program disk minimization volume minimization investigated summary data presented discussed vehicle investigation based simulation model early framework time sharing based variable segments dynamic overlay procedure data presented effectiveness type organization time sharing environment design characteristics operational capabilities simulation model core usage operating model minimization simulation volume minimization simulation time sharing
policy driven time sharing service received process time sharing operating characterized resource count sum ij ij number units service received process resource cost unit service class users characterized policy function amount service user class function time priority function difference service user policy function service scheduling resource count process policy function provide level service overhead reduced avoiding process received level service implemented general purpose operating provided significantly service interactive batch jobs previous time sharing operating resource allocation
conversion limited entry decision tables programs proposed modification proposed converting decision tables flowcharts minimize subsequent execution time compiled program modifications proposed coding theorem communications concept completely test rule modification completely tests rule results modification modifications result modification optimal solution coding decision table information theory channel sorting
comment conversion decision tables programs january decision tables diagnostic aids analysis business applications
comment certification january proof algorithms debugging certification sorting place sorting
linear programming january linear programming dual simplex method primal problem dual problem
complex gamma function s14 january jr gamma function gamma function asymptotic series recursion formula formula
circular integer partitioning a1 january taylor partitions statistical design experiments
evidence analysis algorithms programming problem purpose note report computational experience additional recently summarized algorithms linear programming problem error paper utility algorithms january operations research integer programming variables algorithms
proof program find proof correctness find description purpose program method systematic technique constructing program proof process coding logical errors proof termination separate finally conclusions relating general programming methodology drawn january hoare proofs programs programming methodology program documentation program correctness theory programming
comments method deadlock discussed deadlock defined state resource processes shown artificial method situation processes resource requests shown deadlock necessarily eliminate method january multiprogramming time sharing scheduling resource allocation deadlock
construction rational formal series methods generation formal series poisson series chebyshev series shown elementary operations addition multiplication rational positive series constructed approaches theorem iteration methods methods relationship pointed classical formulas obtained cases shown convergence properties formulas improved additional computations finally end article numerical experiments chebyshev series fourier series january series expansion series inversion root extraction theorem newton chebyshev series poisson series fourier series
language geometric patterns dimensional space paper problem oriented language geometric patterns dimensional space presented language specifically designed automatic generation integrated circuit suited problems architecture design planning logical block representation design criteria structure specific features illustrated january graphic language problem oriented language dimensional patterns graphic display fortran extension layout problems integrated circuit architecture design planning
reconstruction binary patterns projections projections finite binary pattern construct original pattern paper give patterns projection algorithms developed patterns shown pattern time pattern similar pattern constructed time dimensions pattern frame january pattern reconstruction image reconstruction data compression pattern recognition integral geometry
pattern width angle pattern feature width function angle interpretations demonstrated paper width concept pattern recognition concept object work word description made precise algorithms feature extraction obtained focus theoretical subject results set definition width angle theorem relating pattern boundary vector descriptions calculated graphical tabular comparisons substantial variation width angle found principal set width angle pattern feature easily computed investigation information contained part width function recommended cases computation width angle difficult january feature extraction pattern recognition figure properties picture processing integral geometry width angle extent integral projections linear pattern measures width functions
simulation codes subject study years man years code history pertinent activities students solution number aid version independence reasons technology perform analyses process encoding yield construction encoding method employs document words simply letters words random match letters words random match letters text message sequence numbers written final code primitive process advantage relative security source document work univac includes analytical studies types simulations entire process simulated encoding schemes machine analyzed synthetic codes messages hand variety methods obtain simulations provide evidence process data dependent strongly real time correct source document common january codes independence encoding simulation
roots matrix december eigenvalues matrix roots roots january
decision table translation december decision table decision table translation january
remarks characteristic values solutions differential equation exponential integral systems algorithms december fortran standard january
december
squares surface fit december january
december numerical integration integration rule adaptive integration automatic integration simpson rule numerical quadrature quadrature rule adaptive quadrature automatic quadrature round error control january
pseudo random numbers g5 december pseudo random numbers testing random number generators january
product type point gauss legendre simpson integration d1 december numerical integration product type quadrature gaussian quadrature simpson rule january
product type point gauss legendre simpson integration d1 december numerical integration product type quadrature gaussian quadrature simpson rule january
product type simpson integration d1 december numerical integration product type quadrature simpson rule january
product type integration december numerical integration product type quadrature integration january
trace driven modeling analysis cpu scheduling multiprogramming level job data obtained production environment event driven software drive model multiprogramming cpu scheduling model technique called trace driven modeling accurate production environment testing variations time scheduling methods easily carried controlled effects relationships scheduling methods tested included worst methods traditional methods multiprogramming theory round dynamic relative scheduling methods concluded successful cpu scheduling method job cpu long period december iii scheduling cpu scheduling multiprogramming performance measurement trace driven models january
levels language software increasing amount software implemented form software designed machine independent language map language macro processor assembly language desired object machine design machine independent language key factor operation paper discusses relative language high level low level presents comparative results december brown software level language machine independent macro processor efficiency january
criteria systems modules paper discusses mechanism improving flexibility allowing development time effectiveness dependent criteria modules design problem presented conventional decomposition shown distinct advantages goals outlined criteria discussed decomposition implemented conventional assumption consists subroutines efficient cases alternative approach implementation effect december software modules software engineering index software design january
method solution problem equations integral equation representation partial differential equations equations defined domains initial problem solution integral equation method successive approximation inherent advantages methods error bounds methods order size depending finite difference approximations involved december moore equations problem method successive approximations january
comparison multivariate normal generators methods generating multivariate normal random vectors variance covariance matrix presented comparison made determine method requires execution time memory space ibm methods basis standard gaussian random number generator results comparison method based triangular factorization covariance matrix generally requires memory space time methods december random number generator normal distribution multivariate normal distribution multivariate normal generator january
methods sampling exponential normal distributions corrigendum december january
weighted linear search scatter tables linear search hash tables step function key presented comparisons methods terms efficiency computation complexity method tables size full table searching primary clustering low cost december linear search weighted search scatter storage hash table key hash address clustering search length january
method compiling languages nested statement structure method incremental compilation presented programming languages statements nested algol pl method permits editing source language general purpose text editor incremental processing entire routines essential points method syntax language restricted constructs occur lines internal data structure called skeleton represent statement structure partially sense modified lines occur set editing commands received parsing compilation parts individual lines handle relationships lines december incremental compiler interactive programming language january
index matrix paper describes scheme symbolic manipulation index expressions arise product symbolic manipulation expressions matrix authors previous paper scheme attempts program optimization original machine code goal automatically generate code handling address calculations complicated data structures paper indexing position relationship indexing indexing position discussed december address calculations transformation compilation data structures indexing indexing position index index map index range matrix expressions normal form programming languages program optimization range operations symbolic manipulation syntactic analysis formed expressions january
dynamic partitioning array languages classical process partitioning array extended array language operation modes partitioning defined types arrays original array arbitrary manner definitions examples illustrate partitioning array languages general interest data structure partitioning consists dynamic tree structures derive array control information sufficient detail design array languages description presented paper implemented array language development university december dynamic partitioning array partitioning array language data structure tree structure programming language design array control blocks partition control blocks january
comments music composition november artificial intelligence heuristic programming models processes music composition music theory january
comments dijkstra concurrent programming control problem november critical section concurrent programming control multiprocessing january
note optimal trees november file searching tree binary search tree january
additional results key address transform techniques fundamental performance study large existing files november hashing hashing techniques hashing methods hash coding keys key transformation key address transformation direct addressing direct access method random access file organization file search scatter storage information retrieval january
modified incomplete gamma function s14 november modified incomplete gamma function incomplete gamma function square distribution function poisson distribution function january
exact probabilities tables november probability table test significance january
approximate method generating symmetric random variables method generating values continuous symmetric random variables fast requires essentially memory easy developed method uniform random number source based inverse function lambda distribution continuous theoretical distributions empirical distributions frequently simulations method simulation november simulation monte carlo probability statistics approximations random variables random numbers distribution january
garbage collection virtual memory systems list processing demand space program execution paper examines practical implications growth virtual memory garbage collection techniques virtual memory systems compares traditional methods discussion simulation november garbage collection virtual memory list processing paging segmentation page tables january
conversion limited entry decision tables optimal optimal flowcharts algorithms algorithms optimal optimal flowcharts limited entry decision tables presented account rule frequencies time needed test conditions algorithms called optimum finding flowchart minimizes execution time decision table simple rules complex rules called optimum requires fewer calculations necessarily produce optimum flowchart algorithms derived decision tables rule optimum shown valid tables including rule algorithms compared existing applied large decision table derived real case comparison conclusions drawn optimum lead results comparable existing require computation time general greater computation effort needed optimum finding small reduction execution time obtained november decision table optimal programs search january
derived semantics programming language constructs constructs simple programming language introduced terms values side effects translator defined language flowcharts simple machine action machine executing flowchart defined proof constructed effect executing program expressed terms side effect program constructing proof formal definitions concepts side effect derived order make proof correctness implementation involves checking definitions derived step description step november lambda calculus formal description program correctness programming languages semantics january
model type checking current programming languages computation classes objects numbers strings functions correct compilation execution question program constructed operations compatible activity answering question called type checking paper attempts notion type checking presents partial solution type checking problem based abstraction application functions program expression subset lambda calculus type relations program information determination type correctness program reducing lambda calculus expression normal forms constant correct type correct program constant error application type checking algol made problems notion type checking discussed november type checking types lambda calculus models programming languages syntax semantics compiler writing language implementation formal definition january
highly parallel approximating zeros polynomial real zeros based newton method simultaneously zeros polynomial real zeros suitable parallel computation determines starting values convergence zeros multiple zeros readily determined point method polynomial november parallel numerical algorithms real polynomials real zeros newton method starting values convergence january
algorithms properties floating point arithmetic algorithms presented form fortran subroutines subroutine radix number digits floating point numbers rounding machine run methods shown work floating point november floating point arithmetic high level languages philosophy language design january
comparative study programs differential equations study comparing performance programs systems ordinary differential equations reported integration methods represented include methods single step methods runge kutta methods polynomial rational testing procedure evaluation criteria applied set test problems programs tested included problems criteria investigation found program based rational performance november ordinary differential equations integration program comparison certification january
date conversion october date calendar fortran statement function arithmetic statement function january
interpolation smooth curve fitting based local procedures e2 october interpolation polynomial curve smooth curve fitting january
human factor programming corrigendum october january
sorting natural selection family sorting algorithms proposed members make memory space yield longer strings extensive simulation results presented implications applications discussed october algorithms sorting replacement selection expected string length january
conversion decision tables rule mask method rule mask algorithms generating programs decision tables algorithms handling limited entry extended entry mixed entry tables algorithms based rule mask method execution time perform logical operations end process execution time considerably reduced rules applicable algorithms conditions tested algorithms degree advantages mask methods tree methods october decision tables rule mask rule mask method rule mask technique program generator january
generating english semantic networks generating english sentences form semantic nodes word sense paths primarily case relations grammar form network ordering set syntactic transformations expressed lisp functions generation information semantic network generation paths grammar designed computational tool develop study methods generating surface strings underlying semantic structure initial finding regard form form rules sentences attention substitution reported programmed lisp authors october semantic grammars case relations semantic generation generation january
integral equations inversion integral equation kind basic problem considered strategy essential points fit experimental data curve properties derive properties function computation function singular decomposition function approximation represents probability distribution number test cases presented set actual experimental data analyzed procedures presented october integral equations kind constraints singular analysis january
methods sampling exponential normal distributions methods distributed random numbers distributed quantities efficient compared terms memory requirements speed algorithms number procedures convert taylor series directly sampling steps approach sampling continuous distribution exponential distribution definite made case normal distribution choice algorithms faster space methods october random numbers pseudorandom normal distribution exponential distribution exponential distribution simulation numerical analysis january
demand paging utilization working sets ii hardware implementation ii working set model demand paging introduced denning discussed characteristics ii description basic demand paging scheme memory added ii hardware finally description hardware design implementation working set model discussed specification actions conditions arise operation full working set model demand paging october morris demand paging dynamic storage allocation ii memory allocation level store paging paging associative memory storage allocation virtual memory working set model january
information storage retrieval avl trees september binary trees search trees information storage information retrieval january
braille terminal september blind programming aid braille braille character set braille character translation braille communication braille terminal braille terminal communication terminal january
comment deadlock method september multiprogramming time sharing scheduling resource allocation deadlock january
problem block tridiagonal matrices september linear algebra eigenvalues eigenvectors partial differential equations january
comparison floating point summation methods september summation floating point addition truncation error error propagation january
algorithms rectangular triangular arrays report algorithms developed rectangular triangular arrays approach development results produced algorithms presented relative algorithms compared found operating triangular array sensitive image yield image reduced number points concluded operating conjunction array features arrays september algorithms rectangular triangular arrays image processing skeleton january
solution matrix equation f4 september linear algebra matrices linear equations january
routine quadratic linear programming problems program based presented solve linear quadratic programming problems program tested wide range problems results extremely satisfactory september linear program quadratic program problem simplex method january
automatic error analysis determining precision problem considered evaluating rational expression desired variable precision floating point arithmetic operations automatic error analysis technique determining directly results low precision interval arithmetic calculation precision data accuracy required achieve desired final accuracy technique easily evaluation expressions september error analysis interval arithmetic precision control january
approach automatic scanning contour maps problem automatic contour maps discussed structure general contour map analyzed topological properties utilized developing scanning problem detection recognition contour lines solved method shown maps normal contour lines called lines problem involved practical scanning discussed solution based minimizing memory space control program suggested september automatic scanning contour maps contour lines detection recognition january
file organization consecutive retrieval property consecutive retrieval property important relation query set record set existence enables design information retrieval minimal search time redundant storage important theorems consecutive retrieval property proved paper conditions consecutive retrieval property exists invariant established outline designing information retrieval based consecutive retrieval property discussed september file organization consecutive storage consecutive retrieval information retrieval record organization query structure record structure storage tapes storage space minimum access time january
cellular arrays solution graph problems cellular array dimensional type identical modules cells cell bits memory small amount logic array computational advantage offered cellular arrays improvement speed achieved parallel processing paper shown cellular arrays suited solution graph problems matrix graph easily array matrix element stored cell array typical row column operations readily implemented simple cell logic major effective cellular arrays solution graph problems determination algorithms parallelism problems solutions serial algorithms presented solution spanning tree distance path problems direct applications routing pert analysis analysis types networks algorithms computation time cases rate log2 number nodes graph straightforward cellular implementations serial algorithms problems require steps implementations require steps september graph theory cellular logic memory arrays parallel processing special purpose computers algorithms distance spanning tree problems january
directed graph august jr moore graph theory directed graph shortest path program optimization optimizing compiler january
roots polynomial august polynomials roots polynomials theory equations criterion january
note generation permutations august read permutation permutation generation january
comment average binary search length august searching binary searching record retrieval january
van device august morris jr local procedure january
comment composition semantics algol august van programming primitives programming languages algol semantics recursive composition design programming languages data structures january
compiling fixed point august compiling fixed point arithmetic january
model memory paging machine paper concerned aspects main memory resources multiprogrammed operating demand paging model presented number page main memory problem program time memory configuration represented explicitly model cpu requirements page characteristics program material statistically expressions distribution number page executing program long run expected program execution time number page average execution interval multiprogrammed load obtained pointed demonstrated numerically increase obtain average execution interval multiprogrammed load resulting equal fixed partitioning main memory august paging machines demand paging operating systems studies analysis memory memory management january
environment research microprogramming development research project microprogramming state university evaluation machines support research decision machine appears superior considered organization definition goals group project reported emphasis early results achieved research august jr microprogramming systems language processors input output systems program project management hardware evaluation january
extensible editor small machine disk storage design philosophy developing sophisticated utility program illustrated actual design implementation text editor data structure employed small number programmed subroutines types data manipulation data structure illustrated ease powerful extensions implemented terms basic editing function august command processing context searching executive program garbage collection interpreter list processing macro language paging parameter substitution recursion state table storage allocation string manipulation text editing virtual memory january
political problems political considered method presented criteria discussed including population natural political criteria considered population data specific results ten state results feasibility political aid august political equal population population units january
generating parsers grammars grammars level grammars similar van level grammars definition algol grammars shown equal power van grammars suited parsing based recursive procedures paper presents bottom scheme parsing based extension floyd production language included similar converting large class grammars paper briefly conversion grammars general extensions definition grammars august algorithmic language processing bottom parsing floyd production language parsing syntax directed compiling translator writing systems level grammars january
computers employment relationship computers employment part general relation technological change employment obvious effect increase due technology eliminate jobs technology individual nature amount work attitudes work technological change structure entire central importance effects impact technology subject extensive study political single discipline studies conclusions political issues present arguments support july gotlieb employment social implications attitudes technology january
computers period acm large characteristics developments july history computers january
view history digital field emphasis universities developments article records events early years people organizations computers period part united july history history january
today programming languages attempt conceptual writing today program early approach programming language lead practical features standard today programming languages investigation interest provide lead state programming terminology presented extent published literature july higher programming languages programming theory programming history programming january
algorithms early mathematics discussed aspects greatest interest science number english july knuth history computation number sorting january
dynamic document processing current role computers automatic document processing briefly outlined reasons early library documentation processes dynamic document environment outlined files information interactive user controlled search process methods automatic query modification based user continuous reorganization stored information function earlier file processing normal collection growth proposed procedures provide powerful tools information retrieval control dynamic library items added july automatic indexing automatic search retrieval iterative searching library processing collection growth collection feedback search january
computers society survey computers society range activities found future scope applications limited future designers programmers decision respect human significant factor improving efficiency process expected usage costs forward expansion usage july systems applications data data management engineering analysis information systems january
computers process directions research development survey applications process suggests professional effective educational systems july education january
language analysis language oriented detail desirable implications science science data construction testing models widely paper major role language analysis areas precision analyzing literature teaching student write composition important july language analysis science pattern recognition pattern generation january
perspective information development development point view commonly computing generation scope development technological world view examined july computing management data processing hardware systems software systems systems development process functional systems management systems january
present future scientific computation expected application computers physical sciences july scientific computation january
evolution storage structures data base management systems power complexity history data processing computers original concepts terms concepts data structure graphic technique illustrate concepts structural relations exist concepts point evolution july block device field extent file page record physical record logical record volume set class set class data structure storage structure physical storage structure logical storage structure storage allocation structure integrated data store index sequential hash item january
requirements advanced programming systems list processing list processing systems designed facilitate production large programs manipulate large complex symbolic data paper presents number features author important improve programmers working domains view language features algorithms coded language form modified made efficient run data general framework requirements applicable design advanced programming systems wide range applications aspects programming systems good interactive facilities control structures sophisticated data communication mechanisms interactive features facilitate program composition entry testing debugging editing optimization implementation generalized environment structure model programming control including coroutines alternative methods procedure required include pattern monitoring condition extended data forms storage management data retrieval function evaluation syntax directed input output data facilitate complex data july list processing programming languages design programming languages interactive systems control structures data structures programming primitives semantics advanced programming systems january
production mathematical software made steps creation mathematical software steps suggest effort creation center focus activities area july mathematical software programming january
programming languages history future paper discusses history future programming languages higher level languages difficulties writing history key part paper tree showing development languages reasons languages major languages reasons importance section significant previous time major topics key concepts specific languages discussed july programming languages higher level languages languages history future directions language programming language tree programming language history programming language future january
programming systems languages pl fortran cobol languages world production programs written future great deal theoretical interest algol extensible languages practical impact problem oriented languages important language development area ten years operating area major set produce multiprogramming systems similar problems number university directly comparable greatly understanding operating principles important include increased interest development measurement evaluation techniques increased microprogramming programming functions july languages operating systems programming systems multiprogramming history january
role models performance evaluation models means performance paper examines models methods evaluating performance systems model july modeling evaluation performance analytic models simulation models models january
operating performance current future positions respect operating performance great deal information large number models developed exist knowledge interactions operating model total developed design performance aspects operating total designs today common future design philosophy impact operating systems july operating performance evaluation performance measurement measurement techniques structured programming paging virtual memory input output disk storage facility drum storage facility queueing january
structured multiprogramming paper presents proposal structured representation multiprogramming high level language notation explicitly data structure shared concurrent processes operations defined meaning programs permits large class time dependent errors compile time combination critical regions event variables enables programmer control scheduling resources processes degree desired concepts sufficiently operating systems user programs july structured multiprogramming programming languages operating systems concurrent processes shared data mutual exclusion critical regions process communication events january
interface computers data communications systems future systems computers digital terminals communications equipment present design optimization problems require traditional functional standard means computers digital terminals communications systems required consideration problems coordination synchronization error control control addition minimizing technological specific designs focus problems obtained discussion detailed specification communications interface july communications standard interface communications virtual channel input output coordination input output january
view architecture attempt made developments years field architecture single provide logical functions devices design computers july architecture projection design organization january
general theory special functions list number natural developments field algebraic manipulation general theory functions defined ordinary differential equations discussed made recent developments mathematics generate properties solutions differential equations theory general effort make algebraic manipulation systems usual special functions exponential july algebraic manipulation special functions algebraic simplification symbolic integration algebraic geometry differential algebra january
management science view nonlinear programming history integer continuous nonlinear programming presented current practical mathematical programming techniques nonlinear programming made years theoretical documentation standard test problems construction user oriented software comparisons algorithms demonstrate techniques specific problems july integer programming linear programming mathematical programming nonlinear programming quadratic programming management science operations research algorithms january
numerical mathematics science numerical mathematics viewed analysis continuous algorithms components numerical mathematics discussed finite precision number systems computational complexity synthesis analysis algorithms analysis error programs program july numerical mathematics science mathematics computation algorithms continuous algorithms january
point approach theory computation point theory semantics programs defined terms points recursive programs existing verification techniques extension handling uniform manner properties programs including correctness termination equivalence july verification techniques semantics programming languages points recursive programs computational induction january
automata theory source ideas automata theory study mathematical development theory paper suggests ways automata theory years understanding processes information july automata theory theory network complexity resolution redundancy potential command mode selection january
instruction june assisted instruction adaptive instruction january
science june education engineering science curriculum systems design january
calculation fourier integrals june quadrature filon quadrature integration filon integration fourier coefficients fourier integrals fourier series spline spline approximation spline quadrature january
integer programming problem june johnson integer programming change making problem january
special series summation arbitrary precision june function evaluation series summation approximation january
random vectors uniform solid angle june random vector generator points uniform symmetric probability distribution january
general random number generator june random number generator probability density function transformation distribution function january
eigenvalues eigenvectors real general matrix june eigenvalues eigenvectors qr matrices general matrices january
complex error function june error function complex argument function special functions function evaluation january
sorting problem complexity technique proving sorting algorithms finding minimum maximum elements set comparisons proved optimal technique june sorting computational complexity computational january
starting method solving nonlinear integral equations kind fourth order starting method integral equations kind numerical examples presented june integral equations starting method january
assigned codes desirable convert codes conversion generally accomplished study conducted test feasibility descriptions numerical codes program primary emphasis computerized construction reference file descriptions program results study show procedures feasible june coding reference list response patterns word strings concept translation word coding january
boolean matrix method computation linear precedence functions modified version bell boolean matrix method computation linear precedence functions conflict free matrix precedence relations precedence functions exist exist action sufficient conditions existence precedence functions boolean matrices prove existence precedence functions classes conflict free grammars illustrated june precedence grammars context free parsing january
blocks data type data type called block implemented block dimensional characters form dimensional extension string dimension blocks printed dimensions basis program defined connection points blocks size shape environment blocks operations output variety graphical problems including logic diagrams mathematical equation text preparation programmed appears easy natural addition specialized applications blocks good general purpose device independent output mechanism suitable work concept block language blocks require specialized syntax readily external structure programming languages june character manipulation output string processing graphics programming data types dimensional mathematics test processing january
interference communicating parallel processes kinds interference communicating parallel processes examined dijkstra knuth solutions mutual exclusion problem form parallel programs proofs correctness solutions paper parallel processes machine state collection pertinent data values process configurations state transition rule set rules yields sequences states behavior mutual exclusion problem formulated questions inclusion sets states existence sequences mechanical proof procedure shown prove correctness prove solution respect interference properties shown transition rules partial rules individual processes operate partial rules calculation transition rules applicable hardware processes software processes processes required june concurrent programming control processes formal programs interference mutual exclusion operating systems parallel processes january
proposal pseudo virtual memory systems solve storage size problems large programs appears overlay scheme balanced combination capabilities found existing techniques proposal presented capabilities existing schemes additional features overlay capability virtual memory effect programmer required design overlay configuration overlay structuring complex task tools including graphic display included proposal order aid programmer design content briefly discussed noted details final overlay configuration fact june overlay overlay structure segment segmentation paging linkage editor collector virtual memory january
optimization performance time sharing systems simulation simulation model time sharing finite store infinite auxiliary store study variation parameters store size number jobs allowed execute simultaneously job scheduling effects variations measure performance parameters job scheduling including scheduling require optimization parameters scheduling effect performance performance based cost jobs processed shown significant improvements measure performance obtained variable time techniques selecting optimum round cycle time appears features optimization parameters scheduling performance manner optimization features control scheduling effect measure performance supervisor size store speed cpu comparison made results simulation model analytical equations oriented time sharing systems comparison found june clark time sharing simulation studies optimization measure performance scheduling algorithms january
curriculum recommendations graduate professional programs information systems education related information systems organizations discussed curriculum proposed graduate professional programs universities master level material programs identified courses incorporating detailed descriptions presented program organization discussed implementation questions considered education management systems systems analysis management information systems information systems development information analysis design january
minimum redundancy coding method information theory coding theory method minimum redundancy coding january
fourier cosine integral d1 numerical integration quadrature adaptive quadrature filon quadrature fourier coefficients fourier integrals january
merge sort m1 sort merge january
generation random normal variables g5 random number normal density normal distribution gaussian density gaussian distribution simulation monte carlo january
clenshaw quadrature d1 quadrature chebyshev series cosine transform fast fourier transform january
formula product formula january
minimax nonlinear approximation approximation subsets minimax approximation nonlinear approximation subset january
fast finite difference solution problems number equal method solving equations numerically results fast numerical method problems equation order equations simple process essential convergence application made type problem numerical analysis partial differential equations equation boundary problem january
implementing clenshaw quadrature ii computing cosine transformation paper methodology automatic clenshaw quadrature scheme quadrature formula scheme requires cosine transformation values shown high cost cosine transformations clenshaw quadrature problems related cosine transformation conventional computation cosine transformation recurrence relation numerically low frequencies effect integral case automatic scheme require sampling storage required values cosine transformation computed part paper shows cosine transformation computed modification fast fourier transform problems modification applicable requiring cosine transformations polynomial interpolation chebyshev points fast fourier transformation cosine transformation clenshaw quadrature chebyshev series january
implementing clenshaw quadrature methodology experience clenshaw quadrature important automatic quadrature scheme variety reasons high accuracy obtained values received requires computation cosine transformation arithmetic cost paper parts paper ii computing cosine transformation shows computing cosine transformation modification fast fourier transform part discusses strategy error estimates experience implementation scheme clenshaw numerical integration automatic quadrature error estimates chebyshev series january
technique software specification examples paper presents approach writing specifications parts software systems main goal provide specifications sufficiently precise complete software written additional information secondary goal include specification information goal technique illustrated means variety examples tutorial software specification modules software engineering software design january
simple approach line computing line operating part normal batch cdc required man initial software implementation simple elements input files batch execution provide results user terminal designed developed part project cost man design parts aspects including design criteria implementation cost overhead user time sharing remote computing line access line computing remote file real time implementation effort operating overhead user remote terminals operating january
multics virtual memory concepts design experience line operating systems share information users systems permit degree sharing sharing accomplished allowing users share data input output information stored files secondary storage segmentation multics direct hardware addressing user programs information independent physical storage location information stored segments independent size access design implementation considerations segmentation sharing multics discussed assumption information large main memory size main memory systems limited shown multics software effect large main memory segmentation paging hardware operating multics virtual memory segmentation information sharing paging memory management memory hierarchy january
improved index sequential access method overflow index sequential access method important file management systems head disk devices study method overflow records method hashing techniques space records conditions satisfied superior conventional method chaining overflow records linked list techniques conditions long overflow significant overflow lack disk space constraints record keys small compared total record size significant file index sequential mode overflow time record dependent total volume overflow records conventional space overflow records index sequential hashing scatter storage disk overflow january
comment double tree april file searching double tree binary search tree january
note nonrecursive list april list garbage collection january
linear equation f4 april matrix algorithms linear equations fortran paged memory virtual memory array processing january
minimal spanning tree april spanning tree minimal spanning tree spanning tree january
complex gamma function error control s14 april complex gamma function gamma function complex log gamma function function round error control inherent error control run time error estimates error estimates special functions january
matrix computations fortran paging efficiency conventional fortran programs matrix computations improved order nested loops modifications produce savings common situations significant savings large problems run operating paging april matrix algorithms linear equations fortran paged memory virtual memory array processing january
complex gamma function error control compute gamma function log gamma function complex variable presented standard modified function reduce round errors addition computation function values includes object time estimation round errors experimental data regard effectiveness error control presented fortran program appears algorithms section april complex gamma function gamma function complex log gamma function function round error control inherent error control run time error estimates error estimates january
computers society proposed purpose paper describe concerned effects computers society society impact computers divided components political economic social main part paper component presents examples relevant issues discussed outline selected set references proposal make courses subject april computers society social implications proposal january
implemented graph switching tutorial paper program switching graphs program good implementation graph algorithms switching game goals moving existence strategy simple strategy explained paper valid cases fact major routines april graph algorithms graph processing switching game graph theory programs game theory trees january
hidden lines elimination object method presented determining parts dimensional objects visible objects paper describes polygon comparison scheme relationships polygons tree types discusses relationship pair polygons table defined pair polygons fixed long means determining visible hidden line relationship polygons additional work extend approach simultaneous april hidden line problem display programming graphics displays graphics drawn picture january
experimental laboratory pattern recognition signal processing interactive controlled scanning display operation ibm research center years includes process control digital mode vector displays input output facilities variety experimental equipment design programming support typical applications control character recognition image processing presented april pseudorandom displays interactive terminal image processing pattern recognition january
communication resource sharing network communication processes time sharing communication extended processes distributed network application existing network discussed april communication time sharing networks resource sharing january
implementation security measures information systems security information represented model matrix elements decision rules row column users data items set functions access matrix translation execution time data dependent data independent decision rules enables perform checking security translation time execution time model security features existing systems framework proposal general security implementation today languages operating systems april security privacy access control operating systems access management data management information systems january
properties working set model program working set time set distinct pages recently pages relations average working set size page rate interval distribution derived time average definitions average statistical definitions efficient estimating quantities relation recently paging characterized independent reference model page references statistically independent effects working set size general assumptions working set size shown distributed denning schwartz working set model paging paging algorithms program behavior program modeling january
study storage partitioning mathematical model fixed dynamic storage partitioning procedures examined multiprogramming systems storage requirement programs gaussian process experiments model means model dynamic storage partitioning shown provide substantial increases storage utilization operating efficiency fixed partitioning jr jr storage partitioning memory management dynamic storage allocation space sharing multiprogrammed storage working sets program behavior models mathematical modeling january
comparative analysis disk scheduling policies scheduling policies head compared performance criteria expected time oriented expected time individual request oriented analytical simulation results obtained variance time introduced measure performance showing individual requests choice utility function measure total performance including oriented individual request oriented measures function scheduling policies wide range input loading conditions selection implementation maximum performance policy discussed access time analytical models auxiliary storage direct access storage disk analysis disk scheduling performance criteria memory devices real time systems response time scheduling policies time simulation storage units time sharing systems time january
synchronization communicating processes defined synchronization mechanism prove running processes correctly demonstrated processes messages buffer processes messages buffer formal description synchronization mechanism makes easy prove buffer overflow operate message frame buffer run deadlock parallel programming multiprogramming program correctness process communication process scheduling january
hardware architecture implementing protection protection computations information important utility segmentation memory addressing scheme protection achieved part access computation paper describes hardware processor mechanisms implementing protection mechanisms implementing protection mechanisms cross calls subsequent occur supervisor automatic hardware references performed call user procedure including supervisor identical call user procedure mechanisms arguments cases protection protection protection hardware access control hardware access control utility time sharing shared information segmentation virtual memory multics january
operating based concept supervisory operating organized small supervisor set independent processes supervisor external devices file directory active processes memory handle errors small set primitive functions execute process process request complicated action part supervisor event combining primitives supervisory program part supervisor programs viewed software implemented supervisory paper concepts detail supervisor discusses advantages approach operating systems multiprogramming time sharing processes january
design operating operating experimental multiprogramming concurrent users small produced test effect machine architecture complexity software defined combination software machine feature software features define operating simply paper development emphasis principles design operating systems design levels abstraction machine architecture microprogramming segments semaphores multiprogramming virtual machines processes process communication virtual devices data sharing resource management deadlock january
paged time sharing pdp time sharing implemented pdp special paging hardware developed report set goals important time sharing describes design implementation achieve goals include specifications powerful large memory virtual machine terminal interaction comprehensive uniform file capabilities flexible structure implementation required achieve operational hardware major goals provided reliable service network paging virtual machines time sharing scheduling process structure pdp january
average binary search length ordered lists corrigendum january
reconstruction pictures projections corrigendum january
music composition problem discussed simulating human composition music relevant music problems kind program schemes work discussed previous discussed including program generate short written aspects human composition output presented discussed show characteristics relevant probabilities sequences artificial intelligence heuristic programming models processes music composition music theory january
hidden line plotting program hidden line plot surface plot january
zeros complex polynomial roots roots polynomial zeros polynomial january
dynamic microprogramming processor organization programming corrigendum january
maximum computing power cost factors problem simple analysis economic factors involved comparing large single machine mathematical model derived assist policy decisions computers management scale january
optimizing binary trees sorting items binary trees form quicksort average time proportional log number items tree binary trees longer reduce average retrieval time restructuring tree make uniform length presented discussed compared tree item added retrieving information binary trees global local optimization sorting recursion january
preliminary report general space planning language set programs language solving class space planning problems language extension algol includes means represent objects manipulate test resulting variety constraints algorithms solve problems expressed language heuristic programming language search algorithms detailed automated design architecture heuristic programs space planning january
proposal based interactive scientific community problems created papers mathematical sciences research suggested tree mathematical results terminology users store file current knowledge selecting paper read obtain minimum theorems required background knowledge paper conditions means provided comments readers work interaction author paper describes organized role required readers writers interactive organization scientific community readers writers utility information retrieval trees data structures
symmetric polynomials january symmetric polynomials elementary symmetric polynomials symmetric polynomials polynomial synthesis reverse scheme reverse synthetic division coefficients
transposition rectangular matrix f1 january rectangular matrix
calculation fourier integrals d1 january quadrature filon quadrature integration filon integration fourier coefficients fourier integrals fourier series spline spline approximation spline quadrature
ordering positive january ordering storage retrieval positive functions functions increasing functions function binary chebyshev zeros square continued
quadratic programming nonlinear regression quadratic programming method nonlinear regression linear constraints regression method published july january nonlinear equations nonlinear regression nonlinear programming quadratic programming squares constraints iteration
model simple english model natural language processing based semantic memory network model simple english processes english sentences content restricted format model syntactic analysis eliminate interpretations employs simplified semantic intersection procedure find valid interpretation input semantic processing similar syntactic component includes early parse trees special purpose rules relational notation interpretation input compatible memory structures allowing direct verification familiar concepts addition actions range editing contents memory form question answering examples presented demonstrate model text ambiguities information memory examples actions january natural language processing semantic memory text question answering artificial intelligence human memory simulation
optimizing polyphase sort corrigendum january
student advantages general purpose interactive called discussed advanced implementation basic level interactive features general capability extension user oriented function application feature provide flexible scan capability illustrated interaction level shows students mix advantages independent mode computing dual mode interaction preliminary experience secondary school discussed january basic education computers education extended languages interactive systems
editing test editing manipulation program program operates low cost ray entry display keyboard function applications potential economy operation aspects implementation discussed january editing text ray entry display time sharing
transformation lines curves pictures proposed interesting computationally efficient procedure detecting lines pictures paper points angle parameters computation shows method general curve fitting alternative interpretations source efficiency january picture processing pattern recognition line detection curve detection points point line transformation transformation
binary picture patterns parallel processing binary patterns obtain single elements pattern presented procedure counting patterns matrix hardware implementation large scale integrated technology principal features method small employed elements parallel nature process possibility pattern complexity configuration problems merging patterns process determination maximum number steps obtain single element pattern reviewed discussed network description terms presented january counting binary patterns parallel processing multiple connected pictures
pattern recognition phase problem ray availability interactive dimensional graphics systems powerful digital computers development algorithms environment pattern recognition techniques make number approaches ray structure determination based model building information frame structural computationally tested reference experimental data application standard pattern recognition algorithms fact cross correlation model correct structure computed fundamental measured data compute upper bound cross correlation simple information basis technique structure determination make effective interactive graphics model building cross advantages usual techniques based function large structures significant field interest january pattern recognition phase problem ray interactive graphics
procedures natural spline interpolation december approximation interpolation spline natural spline spline approximation cubic natural spline january
exponential integrals december gautschi exponential integral recurrence relations recursive computation continued january
linear systems tridiagonal matrix f4 december linear equations tridiagonal matrix sparse matrix january
data definition mapping language data definition language language data structures data definition languages logical data structures structures realized data definition languages describe logical physical aspects data languages key systems advanced data management systems distributed data paper past work data definition language describing logical physical aspects data applications generalized data definition languages discussed december taylor data definition language data storage structure data translation data base management systems file translation january
curriculum recommendations undergraduate programs information systems education related information systems organizations discussed curriculum proposed undergraduate program material programs identified courses incorporating descriptions presented program organization problems implementation discussed december education undergraduate curricula management systems information systems information analysis design systems analysis january
solving equation square direct method methods solving equation compared method direct decomposition method iterative solving poisson equation directly iteration november direct method block iterative decomposition january
approximate solution integral equations explicit approximate solution equation assumed classical technique applied assumed fourier transforms explicitly approximate solution depends positive parameters november integral equations approximate solution january
recurrence scheme converting orthogonal expansion generalization scheme converting polynomial chebyshev series combined recurrence scheme clenshaw finite series terms satisfy term recurrence formula november orthogonal series recurrence schemes recurrence clenshaw recurrence term recurrence term recurrence chebyshev series january
tree structured programs november control structures flowcharts statements inductive points optimization compilers program documentation program flow graphs programming language design proof programs semantics programming languages structured programming january
comment scatter storage november low hashing information storage retrieval scatter storage searching symbol table january
note ordering execution arithmetic expressions generating trees tasks execution times presented comparison critical path heuristic discussed november denning graham scheduling tree scheduling task scheduling multiprocessor scheduling january
arithmetic finite field a1 november mckay algebra january
automatic numerical integration finite interval d1 november automatic integration numerical integration automatic quadrature numerical quadrature january
matrix transposition place f1 november transposition matrix operations permutations primitive roots number theory january
combinatorial algorithms g6 november permutations combinations january
student frequency s14 november hill student statistic density function series approximation january
eigenvalues real symmetric tridiagonal matrix f2 november eigenvalues qr january
experiments automatic theorem ordering inference rules automatic theorem made efficient shown axioms partial ordering built inference rules theorem proving based resolution rules partial relationship program developed modified version rules theorem found powerful solving problems involving partial paper presents detailed description program comprehensive account experiments performed november theorem proving partial ordering resolution resolution resolution inference rules heuristics january
scan conversion reduced storage requirements graphics systems raster scan output device display file random scan format scan hardware software provided picture description format raster format published scan conversion algorithms fast buffer area large entire hand small buffer area slow require multiple display file scan conversion linked list data structure process lines drawing groups scan lines small primary memory buffer area binary image group scan lines portion drawing buffer portion list processing procedures single pass display file required generating binary image increase execution time fully core results results slow storage requirements reduced percent percent increase execution time november jr graphics scan conversion raster plotter line drawing discrete image generation january
adaptive correction program statements corrigendum november january
parser generating constructing compressed compilers paper describes parser generating cdc university fortran coded compiler input translation grammar syntactic rule possibly code generator assembly language fortran algol subroutine called syntactic rule applied parse program typical pass compilers constructed source programs compiler parser program tables words bit core memory words parsing table entries words code generators november parser generators translator writing systems syntactic analysis normal form grammars pushdown automata translation grammars translator optimization compression january
dynamic verification operating decisions dynamic verification decision implies time decision made consistency check performed decision independent hardware software dynamic verification operating decisions prime designed constructed university prime experimental time sharing properties continuous availability data privacy cost effectiveness technique dynamic verification construction operating make decisions single hardware software fault multiple lead operation prime dynamic verification user information user single hardware software fault amount additional hardware software required dynamic verification november operating systems data security fault software reliability data privacy program verification modular systems january
programmer november january
algorithms determination generated plots october plotting plotting january
bivariate normal distribution s15 october bivariate normal gaussian frequency distribution january
cubic spline solutions class functional differential equations october differential equation spline approximation january
calculation optimum parameters implicit procedures october elliptic difference equations optimum parameters implicit january
elementary circuits graph october graph theory circuit search path search searching january
discrete linear approximation interval linear programming e2 october discrete approximation approximation january
multiple precision division october multiple precision division overflow january
control structures iv fortran part effort design implement fortran compiler iv extended fortran called developed language means data control structures suitable iv parallelism paper hardware characteristics features expected language compiler design implications features data layout structure discussed drawn data allocation code structuring optimization problem satisfactory method data allocation presented language structures storage method parallel algorithms october array processing parallelism detection explicit parallelism array allocation parallel control structures iv fortran january
page working set parameter denning method selecting working set parameter intervals examined model noted assumptions introduced modified model results page selecting working set parameter october working set model paging program behavior program modeling january
class dynamic memory allocation algorithms dynamic memory allocation introduced similar advantages buddy generalization mentioned includes systems special cases october dynamic storage allocation buddy simulation fragmentation january
note problem note problem program execution information program set examples attempts problem conditions solution stated october protection program privacy security data january
general performance analysis key address transformation methods abstract file concept paper presents approach analysis performance key address transformation methods approach keys file assumed selected key space probabilistic selection files number keys selected key space weighted average performance transformation methods files potential methods analysis methods performance key distributions partial transformations identified approach applied group transformation methods files keys selected october hashing hashing techniques hashing methods hash coding key transformation key address transformation direct addressing random access scatter storage information retrieval hashing analysis performance analysis january
model stack implementation multiple environments control access environment structures require storage procedure exist times control nested procedure straightforward implement dynamic storage allocation linked blocks time space paper presents implementation technique single stack procedure storage storage necessarily control flow technique property simple case runs usual automatic stack allocation procedure applications technique coroutines variables functional arguments discussed initial model single real processor assumed implementation multiple processes coordinate control explicitly multiprocessor implementation requires basic technique october control structures environments stack allocation dynamic storage allocation access environments problem coroutines variables functional arguments multiprocessor systems extensible control structures january
multiple terminals user program control time sharing environment user written programs time sharing remote terminals simultaneously control interactions terminals programs written standard input output instructions language paper describes multiple terminal facility implemented requiring executive compilers interpreters october multiple terminals remote terminals remote time sharing line interaction line january
roots polynomial september january
hidden line plotting program september january
sparse matrix package september january
generation permutations lexicographic order september january
finding graph september complete bound technique recursion january
routing problem september routing problem shortest path problem circuit january
analysis representations symmetric group september williams symmetric group representation partition permutation binary model product january
bivariate error analysis bivariate obtained numerical results graphs functions september numerical integration formulas january
execution september debugging pl execution january
simple technique structured variable simple technique symbol table structured variables based simple automata theory presented technique deterministic solution problem handled nondeterministic manner pl cobol compilers september symbol table organization pl cobol structured variables january
empirical working set behavior working set model program behavior proposed recent years basis design scheduling paging algorithms words working set commonly encountered literature resource allocation published data program measurements field find experimental evidence base theoretical work september virtual memory paging working set software measurement program behavior january
design tree structures efficient standard information retrieval operation determine records data collection satisfy query expressed terms data values process desired represented tree search model paper optimization problem design trees serve application problem academic sense optimal tree implemented means practical techniques hand comparison observed performance search procedure practical application model paper considers design tree search scheme based bit vector representation data shows essentially design search tree bit vector tree experimental study small file concepts september tree file information storage retrieval clustering search data structure data management query answering january
evaluation selection file organization model work discusses factors file data base organization performance subject presents methodology model programmed estimate primarily total storage costs average access time file organizations specific data base query device related specifications based estimates file structure selected specific situation convenient tool study file structures facilitate process data base structure design evaluation september file organization file structures file management file organization performance file organization model file structure design secondary index organization simulation data base access time storage requirement data base analysis data management january
information theory applied conversion decision tables programs ideas information theory paper heuristic limited entry decision table tree structured program minimum average processing time method applicable limited entry decision table require actions single rules cost testing conditions equal general previously published heuristic algorithms compared optimal easy code takes smaller translation time practice suited manual conversion decision tables flowcharts september decision tables optimum programs information measure january
computational algorithms closed queueing networks exponential methods presented computing distribution closed queueing networks exponential expressions distributions derived computational algorithms based dimensional iterative techniques highly efficient simple implement implementation considerations storage allocation strategies order evaluation examined detail september queueing theory queueing networks distributions state distributions january
generalization avl trees generalization avl trees proposed shape small integer experiment performed compare trees standard avl trees balanced trees basis retrieval time amount restructuring expected worst case retrieval time shown units retrieval time increased small amount amount restructuring required factor ten theoretical results derived including correction earlier paper compared experimental data good correspondence found august avl trees balanced trees information storage retrieval january
capabilities statements formed program defined program loops statements nested definition formed flowchart shown program formed written multi level statements sequence control shown statements single level shown flowcharts formed flowchart node practical implications discussed august formed program statement statement statement statement flowchart node software reliability january
inductive proving properties programs main purposes paper extension results computation recursive programs emphasis difference theoretical practical approaches presentation examination methods proving properties recursive programs discussed detail powerful inductive methods computational induction structural induction including examples applications august recursive programs fixed point computational induction structural induction january
roots polynomial august williams january
minimum redundancy coding method august january
clenshaw quadrature august good january
graph plotter august january
efficient prime number generator august january
complex gamma function august january
complex method optimization e4 august optimization optimization january
gaussian quadrature formulas integral d1 august gaussian quadrature integral complex integration numerical inversion transform january
combinations objects g6 august permutations combination january
square august square asymptotic approximation normal square january
function minimization e4 august function minimization method january
speed independent design investigated method modeling speed independent circuits study circuit usefulness modeling speed independent operation usefulness design speed independent processor modules developed investigation implementation august speed independent january
basis program semantics formal presented data item function relation argued suitable set theory derivatives accurate description program semantics shown data types operations structuring demonstrated completely primitive types introduced languages mechanism singleton data types deterministic nondeterministic functions shown local environment data item statements considered functions environment nature recursive functions briefly discussed technique presented introduced technique questions local global environments modes function parameter theory applied proof elementary theorems semantics assignment conditional iterative statements included presents detail formal abstractions paper august semantics formal systems lambda calculus extensible languages data types modes axioms correctness formal language definition formal description data structures description languages models computation january
learning program learning program written basic game incomplete information program principles artificial intelligence programs complete information chess program constructed strategy table situations interactions game parameters entry table determined strategies chosen strategy employs probability analysis linear polynomial evaluation move program approximately situations august smith artificial intelligence intelligence learning heuristic procedures heuristic programming game problem solving incomplete information machine learning table learning programs strategy learning january
minimal spanning tree july spanning tree minimal spanning tree january
hidden line plotting program july collins hidden line plot surface plot january
solution ordinary differential equations july differential equations differential equations boundary problems january
solution linear programming problems variables july linear programming variable january
equivalence graphs context free grammars july artificial intelligence graphs language theory context free grammars january
multiple loop july control structures free programming multiple loops statement january
science july education science curriculum synthesis educational structure january
curriculum recommendations graduate professional programs information systems recommended information systems administration report acm curriculum committee education management proposed proposed include curriculum information systems administration important reasons systems designer framework operate work effectively important objective curriculum recommendations future activity importance reasons addition recommended outlined format original report july education management information systems information systems administration information systems management management january
teaching programming paper presents goals organization programming designed provide students graduate program professional students expected programming courses familiar programming languages students users teaching program similar teaching purposes present set rules producing formed function involved finally source information process student involved july education programming concepts january
distribution program primary fast buffer storage virtual memory fast buffer memory primary memory central processing unit considered optimal distribution program buffer primary memory studied program function expressions distribution program cost time integral primary fast buffer storage obtained buffer management policies july virtual memory function cost time integral fast buffer january
mixed solutions deadlock problem detection provide effective practical solutions deadlock problem individual techniques resource allocation operate paper presents method based concept hierarchical operating constructing suggests frequently resource allocation problems july jr resource allocation operating systems multiprogramming hierarchical systems january
iii chess program iii chess written fortran ibm iii minimal chess game rate cpu time move level lower chess selective tree searching procedure controlled chess multiple minimal game calculations achieve optimal move selection tree searching algorithms effectiveness simple addition interesting called tree searching entire development human standard exponential growth large extent definition set tree selective tree searching made representation chess environment procedure maps regions specific chess algorithms command structure chess program comparison made actions human iii july artificial intelligence selective searching tree searching tree searching heuristic programming chess algorithms regions set minimal chess game control mode game machine learning concept command structure minimax chess auxiliary minimal game january
note information organization storage logical structure data base represented tree graph natural view process designing data base constructing tree graph general method constructing tree graph provided important elements general construction method set binary relations constructing subsets set selecting element set objects relations algorithms results information structures list tree problem information organization storage reduced defining relations algorithms set constraints results presented valuable designers design concepts serve basis developing formal theory subject july data base data base management information retrieval information structure file organization storage allocation tree graph january
resource stage hypothesis based study data processing descriptive stage hypothesis presented suggested planning organizing activities resource change character period time patterns stage stage ii development stage iii stage iv user service stage related individual tasks resource july management stage hypothesis planning organizing control resource january
technical text assisted typesetting means special problems arise highly technical material mathematical formulas solutions problems information american physics include representation special characters mathematical symbols input generation symbols precise floating line words formulas end line aspects error correction june typesetting graphics text processing january
cubic spline solutions fourth order boundary problems cubic spline approximation fourth order differential equation shown reduce solution term recurrence relationship special cases approximation shown simply related finite difference representation local truncation error order june cubic spline differential equations boundary problem january
squares cubic curve fitting matrices involved linear squares formulation determined problem fitting cubic functions continuous derivative arrays data june curve fitting data reduction function approximation approximation splines january
number restricted partitions a1 june partitions enumeration change making level levels january
efficient algorithms graph manipulation efficient algorithms presented partitioning graph connected components components simple paths partitioning graph simple paths iterative iteration produces path vertices paths start number vertices number edges requires time space proportional executed random access june graphs analysis algorithms graph manipulation january
threaded code concept threaded code presented alternative machine language code hardware software software realized interpretive code interpreter extensions mentioned june bell interpreter machine code time space compiled code subroutine calls threaded code january
development decision tables parsing complex decision situations parsing technique proposed parsing based characteristics decision problem requires description problem decision format development decision tables defined avoiding minimizing conditions actions resulting tables june decision tables parsing decision problem analysis january
optimum data base reorganization points data base organization schemes cost access increase due structural caused data base cost access reduced high cost reorganization paper examines strategies selecting optimum reorganization points june data base reorganization files information retrieval january
generated aid analysis generated graphic method conjunction hierarchical scheme analysis illustrated graphic principle representation elements data matrix printed symbols character symbol small plots applied data matrix clustering matrix clustering show clustering set data tests illustrate comparison methods factor analysis methods analysis june graphics analysis numerical hierarchical clustering factor analysis january
optimal code generation arithmetic expressions instruction sets present day computers june arithmetic expressions code generation compilers object code optimization register assignment trees january
shortest latency time drum scheduling discipline systems practical determine drum position discipline determining sequence records accessed called shortest latency time discipline collection length records accessed drum positions discipline necessarily minimize drum latency time show total time access entire collection schedule drum longer minimum latency schedule june drum scheduling shortest access time minimal latency scheduling shortest latency time january
processors memory content generated implementations method processors multiprocessor require memory type instructions scheme called read require memory instructions developed dual pdp real time requirements read method require special read instruction processors special read cycle memory modules processor examines memory location read instruction set sets set event sequence read cycle writing processor set effective interrupt june hill monitors debugging parallel processing associative memories microprogramming january
minimizing space segmentation paged virtual memory finite number page sizes considered algorithms pages segments discussed simple implement problem page sizes minimize expected total space internal fragmentation page table segment solved probability density function segment size expressed convex combination june dynamic storage allocation virtual memory paging multiple page sizes fragmentation segmentation january
efficient multiprogramming resource allocation accounting component time sharing operation multiprogramming questions resource allocation required response criterion multiprogrammed serve resource input output channel program small amount processor usage channel applications principle suggested multiprogramming executive allocation algorithms efficiency allocation resources connected accounting resources problems minimal overhead relative dependent resources allocation algorithms arbitrary accounting parameters accounting extensive overhead multiprogramming prove efficient result multiprogramming allocation memory resource essential control resources general suggestions allocation accounting applied question details provided case monitor virtual memory machine june monitor executive multiprogramming efficiency resource allocation resource accounting january
practical approach resources avoiding resource scheduling allocation regard time space multiprogramming time sharing environments involving large numbers tasks resources requirements detection require additional overhead efficient usage resources resource management program linked lists techniques large portion overhead program running part large scale general purpose operating resources active implemented state permit comprehensive levels deadlock detection additional cost incorporated running due deadlock situations deadlock resource allocation scheduling resource management multiprogramming time sharing multiprocessing january
interactive text editing remote job entry comprehensive manipulating kinds text programs letters typewriter terminals connected facilities remote job entry retrieval facilities text powerful method addressing text content provided paper describes external internal structure short description major features general purpose time sharing operates conjunction included text editing time sharing line text editing interactive text editing terminal remote terminal terminal interactive terminal remote job entry remote job retrieval program preparation document preparation data entry content addressing january
comment practical aspects science education education engineering sciences curriculum systems design january
comment music january
music composition computational linguistics artificial intelligence heuristic programming models processes music composition music theory january
free permutations permutations transposition algorithms permutation permutation generation scheduling combinatorial analysis january
sparse matrix package matrix sparse matrix matrix manipulation fortran standards january
exact solution linear equations residue arithmetic residue arithmetic symmetric residue mixed radix representation symmetric mixed radix representation mixed radix conversion prime number linear equations gaussian elimination matrix inversion determinant matrix condition january
increasing efficiency quicksort sorting quicksort january
linear programming january
linear programming january
january
coulomb wave functions coulomb wave functions wave functions special functions function evaluation january
nonrecursive list moving efficient nonrecursive moving lisp type list requires storage nodes list additional bits node runs time proportional number nodes list original list structure list moving list copying list garbage collection lisp january
array grammar programming package fortran programs developed permits user design test array grammars user control rule selection procedure derivation parse weighted programming matrices choice selection schemes raster random parallel examples involving array languages simple patterns language pictures picture grammars array grammars january
minimal event node network project precedence relations procedure constructing minimal event node network represent set precedence relations parallel activities presented minimal event node network event node network number nodes number precedence relations show presented fisher produces event node networks minimal procedure includes set problem time required number activities gotlieb network project event node network activity node network minimal event node network activity project precedence relations january
hierarchical storage information retrieval probabilistic analysis employed determine effect hierarchical storage organizations information retrieval operations data storage hardware assumed levels connected memory hardware increasing data access times increasing data storage capabilities fast memory core memory extended core storage disk memory data cells equations derived effect data access times sequential files random access files structured files employing multiple hierarchical linked lists information retrieval hierarchical storage january
comments decision tables conversion programs paper comments recently published work decision table translation methods similar rule mask technique applicability methods conventions table meaning discussed argued place multi rule single rule action set decision usage johnson decision tables systems analysis programming january
programming effective decision tables programming aspects decision table programming general purpose programming decision tables construct application program selection source statements file proposed programming general special purpose programming significant class large scale problems elements approach discussed existing application low modeling applications development programmer generation automatic program generation january
problem communicating complex information nature difficulty involved communicating mathematical results based information retrieval examined problem analyzed terms information processing processes effects include ways written natural language linguistic devices structure inherent information communicating sophisticated interactive controlled complex information information communication mathematics proof interactive language january
greatest common divisor integers april good proof algorithms greatest common divisor inductive method january
ten subroutines manipulation chebyshev series april chebyshev series differentiation integration curve fitting approximations january
design implementation evaluation working set behavior dependent algorithms employed resources processes recent research time sharing paging systems developed working set model program behavior source allocation strategy based model proposed implementations principles reported case results report discusses design implementation based working set principle presents data permit analysis behavior future directions research methods april working set time sharing systems resource allocation software evaluation operating systems supervisory systems january
region technique analysis method converting picture map regions regions edges picture solid regions edges propagation process resulting map comparing region regions picture merging regions criteria based size method applied construction cover maps cover pictures obtained april strong iii picture processing analysis edge detection january
approaches match file searching problem searching set keys file find key query key discussed terms key space defined file structures presented search algorithms intended reduce number comparisons required achieve desired result methods derived satisfied graph concepts empirical results presented compare efficiency methods april matching file structuring file searching heuristics match january
statistical study accuracy floating point number systems paper presents statistical results tests accuracy arithmetic systems evaluating sums products products analytic error estimates computations arithmetic systems studied digit digit binary floating point number representations combined usual round modes arithmetic numbers digits modified round mode digits sense arithmetic systems binary number representations shown approximately statistically equivalent usual round mode digits shown statistically superior accuracy usual mode cases modified round mode found superior mode cases april error analysis floating point arithmetic rounding digits number representation january
memory hierarchies study presented implications memory hierarchies backing secondary store small read time relative time required writing read time conventional backing storage devices analytic models introduced shown hierarchies operate ways conventional hierarchies shown situation past backing storage devices symmetric respect read write times situation devices development small read time write time ratio study emphasis read write memory april williams memory hierarchy demand paging memory memory device memory hierarchy paging storage device storage hierarchy virtual memory january
implementation high level language machine computing machines directly execute statements high level language proposed past report describes actual implementation machine machine language machine fully operational correctly operations vectors arrays machine automatically memory statements calls functions numbers type automatically types programmer errors april architecture high level language machine microprogramming interpreters execution speed january
binary pattern reconstruction projections pattern reconstruction image reconstruction data compression picture processing january
binary pattern reconstruction projections pattern reconstruction image reconstruction data compression picture processing january
space optimal information retrieval coding text compression january
graduate education ph graduate education ph production january
testing technique string hashing information storage retrieval january
gray code sign sequence ordered gray code sign sequences ordering positive functions binary sum january
design implementation diagnostic compiler pl pl compiler pl design objective provide maximum degree diagnostic batch processing environment part implicit provided automatically compiler characteristic pl translation program execution user established error requires compiler errors encountered translation execution design pl consideration pl explicit user controlled facilities program testing extensions pl compatibility ibm compiler pl permits pseudo comments contents considered source test comment diagnostic effort pl fast efficient processor effectively compilers provide diagnostic offered sophisticated source language employed compilers debugging pl programming languages january
effects communications study made time division stochastic nature process user performance time shared communications concluded values parameters improvement performance model sense time shared scheduling reduced improvements transmission change communications performance analytical simulation results based model communications queue single exponential analytical results include general description output process queue conditions output process approximately poisson communications time sharing scheduling algorithms operating systems january
end end provide remote terminal access large scale considered problems operating discussed shown intelligence end processing problem specific implementation discussed emphasis main processor link hardware software implementation effect main processor operating advantages line end processor remote job entry remote terminals january
common minimum space text storage method storage space text strings compiler diagnostic messages method hand selection set text strings common messages stored storage technique mathematical optimization problem determine message minimize storage requirement problem overlap exist dynamic programming presented problem time number characters text paper diagnostic messages error messages common minimum space text storage optimization dynamic programming january
science program small colleges acm small programs committee curriculum science unique problems small colleges universities make recommendations science programs report set recommendations courses resources implementation problems discussed specifically constraints limited purposes wide variety objectives detailed description courses suggestions made advanced work extensive library list included science education proposals small colleges programming social implications organization file organization january
solution transcendental equation transcendental function evaluation solution transcendental equation january
properties working set model corrigendum denning schwartz january
design paper advantages concurrent design language operating machine create interactive programming laboratory describes effect move features domains design implemented simplified incremental compilation addressing structure communication mechanisms construction hierarchical suggested important concept operating systems scheduling maintenance functions resource allocation enables scheduling algorithms decision integration correctly performing scheduling decisions concurrent design operating scheduling communication incremental compilation virtual addressing debugging hierarchical january
software design evaluation critical current software design implementation methodology performance proposed design evaluated implemented paper reasons methodology difficulties proposed performance evaluation design implementation based simple high level language describe development source language description direct input performance analysis simulation routines performance information obtained routines feedback problems performance early major proposed graham jr operating development language processing software evaluation compilers programming supervisory systems debugging program maintenance modeling integration simulation january
reducing retrieval time scatter storage techniques method retrieving information hash table method intended efficient entries times expected number entry monte carlo experiments considerably comparable methods table full fortran implementation address calculation content addressing file searching hash addressing hash code linear linear quotient method scatter storage searching symbol table january
automatic error bounds simple zeros analytic functions theorem convergence newton analytic function variable extended include computational errors complex interval arithmetic numerical examples polynomials real complex roots bessel function kind real intervals complex intervals real interval arithmetic complex interval arithmetic newton method theorem zeros polynomials zeros bessel functions january
theory discrete patterns implementation notion discrete pattern properties pattern shown generalization formal language algorithms implementing kinds patterns general approach create bottom parse top specification patterns pattern theory parsing pattern matching string processing pattern implementation january
inference designing programming languages designing programming language existing language designer problem natural grammar language interactive approach grammar design problem designer presents sample sentences structures input inference constructs grammar generalization examples designer implementation restricted operator precedence grammars outlined larger class context free grammars grammar design language definition inference identification extensible languages january
representation regions efficient search representation basic features contour maps region line structures representation practical storage requirements rapid searching large files data geometric position attribute application representation handling information utility algebraic properties data structure make computationally easy determine point closed boundary compute area contained closed boundary generate closed boundary representing union intersection closed determine point minimum point contour map representation region boundary representation search structure graphic data retrieval graphic language dimensional patterns graphics graphic display january
normal s14 january hill normal distribution inverse transform taylor series approximation january
random distribution g5 january random number probability density probability distribution distribution distribution simulation monte carlo january
multidimensional monte carlo quadrature adaptive sampling d1 january monte sampling adaptive quadrature sequential january
mutual recursion algol restricted compilers january algol mutual recursion compiler restrictions january
note chain overflow items direct access table january hash code open hash chaining information retrieval january
practical science education discussion january education engineering science curriculum systems design january
reduction symmetric generalized problem reducing generalized problem lambda ordinary problem case symmetric matrices positive definite order matrix matrices blocks terms blocks reduces generalized problem ordinary problem symmetric matrix similar schwartz reduction symmetric matrices form calculation requires order operation round error calculation order sum errors steps errors determined condition respect inversion january generalized eigenvalues symmetric matrices january
variable precision previous paper presented efficient called evaluating rational expression desired variable precision arithmetic operations applied expressions involving variable precision operations sum error bounds operation precision error operation argument paper presents efficient variable precision exponential operation error bound order operations log simple series handled january variable precision exponential function error analysis interval arithmetic january
adaptive correction program statements method analyzing statements programming language considerable specification proposed method involves principles present studies area artificial intelligence feature extraction approximate tree matching strategy improvement feedback matching process program incorporating principles preliminary operating results presented final section principles investigated january adaptive linguistic pattern matching automatic parsing approximate match compiler program statement analysis syntax analysis january
time required sequence matrix products paper discusses multiplication sequences row vectors column vectors square matrices minimum time required evaluate products ordinary serial computers parallel computers discussed algorithms presented parse matrix sequences subject constraints machine organization january matrix expressions matrix multiplication operation minimization parallel machine time minimization january
protection programming languages linguistic mechanisms function producing functions type schemes considered attempt made access authentication january morris jr protection types environments access keys access control authentication january
hash coded tables space allocation hash coded table table entries space technique presented technique independent length table hashing function utilized conjunction linear table eliminate previously hash coded table change hashing method efficiency technique discussed theoretical statistics january dynamic storage hash code scatter storage january
model multiprogrammed level storage results presented analysis probabilistic model multiprogrammed level storage sequential accesses devices expressions obtained long run probability cpu storage devices numerical results cpu utilization multiprogramming type storage january multiprogrammed storage hierarchical index sets january
heuristic approach inductive inference fact retrieval systems heuristic procedures presented developed perform information procedures make similarity structure data base clustering algorithms implemented model fact retrieval formal query language property list data structure program experiments procedures test data part data introducing data found correct response variety conditions involving incomplete data december inference inductive inference clustering fact retrieval heuristics january
routing problem december january
merge sort december january
hidden line plotting program december january
gaussian pseudo random number generator december random numbers pseudo random numbers gaussian distribution normal distribution january
exact distribution statistic small december test statistic fit testing january
exponential method solution systems ordinary differential equations explicit single step method numerical solution initial problems systems ordinary differential equations presented method designed general purpose nature efficient systems differential equations general order case linear constant coefficients linear terms case method order implemented routine usage applications frequently appears results compared standard fourth order runge kutta implementation computation time required method comparable problems orders faster highly systems december numerical solution ordinary differential equations initial problems systems january
graph formulation school scheduling problem examination schedule problem takes forms literature presented terminology classical network theory formulation network partition nodes minimal number subsets members subset connected obvious lower number size strongly connected proved upper size logical extension previous work introduction variable length examinations number object paper definition strongly connected include nodes present approximate strongly connected discuss application solution school scheduling scheduling problems december scheduling school scheduling examination scheduling network graph strongly connected january
generation gamma random integral shape parameters shape parameter integral generating gamma random variables digital straightforward simple method generating gamma random integral shape parameters common procedure approximately generate random variables called probability method procedure exact due paper presents method generating gamma random variables greater efficiency method shown efficiency method paper integral mix procedures yields combination accuracy efficiency method method greater probability method december simulation gamma random variables probability distribution random numbers january
comparison list parallel processing systems problem scheduling processors minimize execution time program consists set partially ordered tasks studied cases task execution times deterministic execution times random variables analyzed shown algorithms suggested literature significantly execution time schedule graham optimal dynamic programming solution case execution times random variables presented december parallel processing precedence graphs scheduling list scheduling optimization dynamic programming january
analytic model execution task monitor execution task monitor chain give tasks execution priority inverse order cpu utilization history effect bound tasks active cpu bound tasks tasks paper simple model execution task monitor employs study effectiveness monitor improving performance modified strategy monitor control investigated case task execution memory hierarchy december scheduling modeling performance evaluation january
arguments construction community information utility article author approach question design computerized community information technology feasibility proposed project techniques evaluate current techniques existence demand proposed steps group users systems design side effects man world view current proposals community information examined framework drawn society position construction information utility community policy implementation december community information social implications public policy january
programming december knuth january
multiple exists loop november evans free programming control structures multiple exists loops statement january
match problem document retrieval november van document retrieval match clustering file searching matching hierarchy classification january
simple technique representing strings fortran iv november string processing fortran iv string representation structured programming data structures january
data management application field november brown data management retrieval systems january
systems distributed control november dijkstra multiprocessing networks synchronization mutual exclusion sharing error recovery distributed control january
register allocation usage counts paper notion usage counts shows usage counts developed algorithms eliminate redundant computations describes usage counts provide basis register allocation paper compares register allocation based usage counts commonly register allocation techniques presents evidence shows usage count technique significantly techniques november optimization redundant computations common subexpressions register allocation compilers programming languages virtual memory demand paging january
method simple traditional music method method music theory additional heuristics fundamental method set productions sets applicability rules rules operate productions extent generated implementation method presented generally resultant music professional appears full music theory needed hardware required structural levels author address november artificial intelligence heuristic programming models processes music composition music theory formal languages probabilistic grammars january
organized parser input paper describes organized parsing designed continuous speech processes string ambiguity error organized sense local parse structures reliable word input local structures reliability search highly words complete november parsing speech recognition speech understanding transition network local parsing january
improving critical working sets approach program improvement restructuring method suited systems primary memory working set strategy based concept critical working set working set memory reference data method operates trace program shown special cases method optimum experimental results obtained method interactive text editor file operating shown substantial methods proposed literature november program restructuring program segmentation improvement memory hierarchies virtual memory multiprogramming restructuring techniques static restructuring dynamic restructuring working set strategy critical working set january
guidelines computerized information systems report november social management information systems social sciences philosophy january
full time programmers data department area derive estimates number full time programmers employed years figure considerably suggested earlier reports recommended educational courses training programmers basis october programmer employment area survey january
efficient implementation variable projection nonlinear squares problems october january
optimal code generation arithmetic expressions instruction sets present day computers october january
construction synthetic workload october january
function minimization october january
routine quadratic linear programming problems october january
october january
numerical inversion transform october transform inversion january
generation test problems linear programming codes users linear programming codes realized evaluating capacity effectiveness accuracy solutions provided codes large scale linear programming codes assumed generating correct solutions test problems solutions test codes large problems solutions readily paper presents theoretical implementation method generating linear programming test problems solutions method permits generation test problems arbitrary size wide range numerical characteristics october linear programming test problem generation program evaluation program january
back end data base management proposed data base management function back end accepts commands high level language data base task group april report accesses data base secondary storage results advantages configuration discussed experimental implementation called experimental data management conclusions back end approach drawn implementation october data base management information retrieval configurations networks data base task group language data base protection data base back end january
structured data structures programming systems permit arbitrary linked list structures user create complicated structures sufficient protection result data elements performed situation paper creation restricted class data structures correctness program accomplished explicit structure facility restriction operations execution time october structured programming data structures data base management january
note calculation working set size finite length reference string arbitrary structure considered exact expression average working set size terms interval statistics derived discussed upper lower bounds obtained average working set size function shown efficiently obtained set page sizes single pass reference string work developments paper denning schwartz infinite length reference strings satisfy statistical properties derive expression relating asymptotic average working set size asymptotic page rate function working set replacement october working set model paging program behavior january
weighted buddy method dynamic storage allocation extension buddy method called weighted buddy method dynamic storage allocation presented weighted buddy method block sizes original buddy method allowed block sizes extension achieved additional cost bits block simulation results presented compare method buddy method results uniform request distribution buddy total memory fragmentation weighted buddy total fragmentation smaller weighted buddy method requests distributed block sizes october weighted buddy buddy systems memory allocation dynamic storage allocation january
monitors operating structuring concept paper concept monitor method structuring operating form synchronization describes method implementation terms semaphores suitable proof rule examples include single resource bounded buffer buffer disk head version problem readers writers october hoare monitors operating systems scheduling mutual exclusion synchronization implementation languages structured multiprogramming january
information theory approach converting limited entry decision tables programs paper earlier converting decision tables flowcharts minimize subsequent execution time compiled program algorithms considered paper perform limited search necessarily result optimal solutions greater search effort needed obtain optimal solution complex decision tables sufficient savings execution time problem converting decision tables efficient flowcharts problem information theory coding results coding literature limitations algorithms solve decision table problem problems develop improvements information depth search conditions additional conditions added decision table finally information compared proposed recent paper september coding decision tables information theory channel sorting january
order approximation optimum interval september job operations programming random operations programming january
computation splines factorization method e2 september approximation spline approximation january
evaluation modified bessel functions complex arguments september bessel functions functions modified bessel functions gauss quadrature january
dimensional plot program september plotting dimensional plotting january
equivalence reducing transition languages deterministic languages class reducing transition languages introduced shown morris proper simple precedence languages paper result extended showing fact class equivalent class deterministic context free languages september reducing transition languages syntax controlled generators deterministic context free grammars january
interactive graphic display region partitioning linear programming linear programming interactive graphic display implemented solve region design problem partitioning region areas total cost minimum conversational manner user easily obtain boundary service locations area cost functions examples included september interactive graphic display region partitioning area specification linear programming january
precise numerical analysis program description program computing solution small number standard numerical analysis problems accuracy correct decimal computed number bounded interval multiple precision arithmetic operations involving numbers executed interval arithmetic concepts significant digits automatically details problem specification problem computation september interval arithmetic multiple precision list structure error control january
integration ordinary differential equations based continued approximations integration found implementation compared programmed algorithms step step procedure solving initial problem ordinary differential equations designed approximate small integer order solutions differential equations continued obtained manipulating sums taylor series method compared taylor series method taylor series method method shown superior speed accuracy method shown superior solution required method finally pass automatically methods discussed september ordinary differential equations initial problem integration taylor series continued program comparison january
problem list issues computers public policy september acm committee economic effects public computers january
recurrence relations integral similar integrals august recurrence relations integral exponential integral january
interpolation functions interpolation function introduced continuous derivatives composition functions called functions interpolation function extended variable shown efficient fortran program interpolation function obtained point set august interpolation approximation smooth interpolation multi variable interpolation interpolation function approximation function spline function january
gauss harmonic interpolation formulas open bounded simply connected region plane point respect discuss method computing gauss harmonic interpolation formulas point formulas approximate harmonic function terms linear combination values selected points boundary formulas approximating solution problem august interpolation quadrature harmonic interpolation harmonic quadrature problem january
complex method optimization august january
function minimization august january
sets august mckay sets january
precedence network transformation august critical path networks precedence networks january
procedures computing natural splines august approximation interpolation spline natural spline spline january
conversion programs decision tables method objectives problems converting programs decision tables investigated objectives program debugging optimization practice extensions theory computation suggested august decision tables program optimization debugging semantics theory programming systems analysis january
note ordering evaluation arithmetic expressions august denning graham january
solution dijkstra concurrent programming problem simple solution mutual exclusion problem presented operate individual component august critical section concurrent programming multiprocessing semaphores january
graph conditions existence solutions timetable problem sufficient condition presented existence solution gotlieb class timetable problem relationships established class timetable problem graphs place additional restrictions graph constraints class timetable problem recent results convert graphs graphs shown existence graph required sufficient condition august graphs assignment class january
execution time requirements encipherment programs encipherment discussed means data costs established experiments conducted measure cpu time cdc required programmed assembly language fortran transformation measure time move data encipherment encipherment word key encipherment word key double key encipherment encipherment pseudo random key results analyzed consistency runs effects constant errors considered timing rates assembly language encipherment characters pseudo random key characters constant word key equivalent rate required simply move data encipherment fortran tests required times cpu time paper idea time coefficient ratio time time store data encipherment august encipherment security privacy transformations protection january
high security log procedure protection time sharing systems users achieved code involved storing discuss selection suitable suggest purpose polynomials prime superior derived codes august operating systems time sharing systems security january
user authentication scheme requiring operating systems user compares recorded table authentication program depends table paper scheme presented require aspects including relevant code data scheme based function function applied user result compared table entry match authentication user access table determine input produces output paper discusses issues selection suitable arguments difficult argued results finally human engineering problems relating scheme discussed august evans jr operating security security authentication encryption january
technique compression storage data storage large programs blocks text produced efficient methods storing data paper describes techniques cases storage size factor techniques special handling leading encoding symbols groups fixed size unique fixed point numbers efficiency considered pertinent statistics compared statistics information coding techniques august file maintenance information retrieval utility programs text compression coding techniques data storage data management january
formal requirements generation virtual machine systems implemented limited number generation systems ibm previous empirical studies generation systems pdp support virtual machine paper model generation developed formal techniques derive precise sufficient conditions test architecture support virtual machines july operating generation architecture sensitive instruction formal requirements abstract model proof virtual machine virtual memory virtual machine monitor january
capability based addressing addressing schemes making segment tables examined schemes shared addresses explained lack efficient address objects systems direct capability address shown difficulties needed address implementation capability based addressing discussed identify capabilities hardware address translation scheme requires modification representation capabilities suggested scheme main memory hash table obtaining segment location main memory unique code hash table recently accessed segments means set associative registers capability based addressing substantially superior present systems basis protection simplicity programming conventions efficient implementation july addressing capabilities addressing hardware protection protection hardware shared addresses information sharing operating systems utility segmentation architecture january
protection control information sharing multics design mechanisms control sharing information multics design principles provide designs key mechanisms include access control lists hierarchical control access specifications identification authentication users primary memory protection paper discussion current protection mechanism design july multics protection security privacy access control authentication time sharing systems programs virtual memory january
scheduling independent tasks reduce time sequencing minimize time time desirable user minimize point time storage required incomplete tasks paper deterministic model independent tasks introduced results derived extend algorithms minimizing time addition analyzing algorithms shown general time problem independent tasks polynomial complete solution july jr minimizing time minimizing flow time sequencing algorithms optimal scheduling algorithms deterministic scheduling models january
minimal total processing time drum disk scheduling article application minimal total processing time scheduling storage units random requests allowed fixed head drum moving head drum moving head disk storage units considered emphasis relative scheduling discipline respect shortest latency time scheduling discipline results simulation studies presented show scheduling discipline superior fixed head drum applications discipline disk scheduling discipline distinct advantage discipline computational requirements scheduling discipline shown comparable algorithms cases sorting procedure time phase july drum scheduling disk scheduling shortest latency time minimal total processing time storage units january
time sharing general purpose multi user interactive operating digital equipment corporation pdp computers number features found larger operating systems including hierarchical file incorporating compatible file device process ability processes command language user basis including paper discusses nature implementation file user command interface july time sharing operating file command language pdp january
computing sets shortest paths graph algorithms presented construct shortest paths pair vertices directed graph algorithms floyd finding shortest path pair vertices directed graph june graph network shortest path january
information approach text searching direct access systems direct access files information attempt made problems information retrieval maintenance large greater part method presented maps frequency distribution suited implementation storage devices method text string characters words bounded subsets strings frequencies word types members subset index keys retrieval rectangular distribution key frequencies results simplified file organization considerable cost advantages june text searching information theory file organization direct access information retrieval character string bit vector january
multiprocessor operating paper describes design philosophy operating multi processor philosophy realized introduction generalized notion resource physical virtual called object mechanisms presented objects including creation types specification operations applicable type sharing protection reference object application operations defined respect type object mechanisms provide basis extension directions introduction facilities creation highly secure systems june operating protection security january
compact representation contour plots line transmission methods compact representation contour plots tested intended reduce cost contour plots lines methods contour plots lines june contour plotting data transmission remote terminal data january
evaluation statistical software social sciences university types statistical packages general widely data text order provide users basis selection tests made systems results summarized cost performance june statistical computation statistical software descriptive statistics bivariate tables correlation regression factor analysis analysis variance january
exact probabilities tables june january
generation random normal variables june page january
hidden line plotting program june january
hidden line plotting program june january
calculation fourier integrals june january
modified integration june january
minimal spanning tree clustering method june page clustering pattern recognition feature selection minimal spanning trees january
solution equations f4 june approximation equations linear programming simplex method january
minimization character sets paper describes technique character sets digital fast access individual bits considers problem minimizing storage needed tables reduction techniques developed problem shown reduce problem june parsing lexical analysis scanning string processing january
theorem proving language large number strategies inference rules consideration automated theorem proving developing language oriented automated theorem proving paper discusses features instructions language language permits easy extension automated theorem proving programs include strategies inference rules extend ability permit general alternative systems june theorem proving resolution programming languages january
languages estimating program efficiency languages users estimate efficiency programs presented program efficiency estimate written language programming language includes features algol language consists interactive commands users provide additional information program written language output results estimating efficiency processors languages processor syntax directed translator program symbolic formula representing execution time program processor set procedures program processor set procedures algebraic manipulation called user operate formula produced processor examples usage languages included limitations present relation knuth work analysis algorithms directions research discussed june programming languages syntax directed translation symbolic manipulation program efficiency analysis algorithms january
model latency dynamic disk allocation paper presents background algorithms latency disk drum discusses input output blocks data buffer primary memories programmed basic permutation variations nature scheduling algorithms restricted classes programs behavior methods restricted numerical computations matrix partial differential equation methods typical examples shown latency small amount buffer memory methods discussed independent size data base considered buffer memory memory hierarchy permutation latency storage allocation january
algorithms properties floating point arithmetic units floating point arithmetic high level languages philosophy language design january
design number theory package division routine number theory package linked list structures storing integers package coded ibm basic assembly language makes macro language conditional assembly coded division routine determine unique factorization large integers number theory package division arithmetic factorization linked lists january
distributions significant digits roundoff errors generalized logarithmic law derived distribution significant digits random digital integer result determine distribution roundoff errors floating point operations uniform distributions significant digits floating point operations roundoff errors uniform distribution distribution variance january
order correction regular languages method presented calculating string regular language number operations input string viewed correction possibly string intended string calculation method presented requires time proportional number characters method find applications information retrieval artificial intelligence spelling correction systems error correction regular languages regular events finite state automata compiler error recovery spelling correction string match problem correction errors nondeterministic finite state automata january
treatment data types constructing general purpose programming language key providing sufficient set data types operations manner permits natural problem oriented notation efficient implementation language number features specifically designed simultaneously satisfy requirements resulting treatment data types includes programmer defined data types data types routines programmer control type conversion flexible data type behavior context efficient compiled code compact data representation data types modes mode type conversion functions extensible languages data type definition data description language compilation january
reduction compilation costs language programming languages groups users constructed features general purpose language paper describes simulation techniques savings compilation cost approach results suggest function describes effect power language compilation cost expressed language features language cost compiling features needed compilation cost increases design programming languages language compiler design compilation cost algol january
solution transcendental equation april january
generator set partitions subsets april partitions subset generation permutations january
curve fitting splines e2 april interpolation splines curve fitting january
curve fitting splines spline introduced attempt cubic splines avoid critical points defining equations presented efficient method determining parameters computing resultant spline standard curve fitting problem discussed fitting open closed curves plane curves importance fitting contour lines mentioned application april interpolation splines curve fitting january
improved program correctness improved program based proposed program problem theorem proving problem program obtained analyzing proof improved analysis program obtained proof achieved modified variable mechanism correctness improved proved program obtained specification april program algorithms theorem proving finding primitive january
alternative approach mutual recursion algol restricted compilers april algol mutual recursion compiler restrictions
remarks structured variables april pl symbol table structured variables references compilers
paper april parallelism polynomial root finding real zeros
teaching machines solution language problem april education programming languages
graduate education ph response april graduate education ph production
study graduate school business april jr education management business january
parallelism tape sorting methods employing parallelism tape sorting presented method natural parallelism method approximately achieve goal reducing processing time divisor number processors april tape sorting parallelism external sorting queues january
copying list structures bounded workspace algorithms presented list structure copying bounded workspace primarily theoretical interest shows cell bits task performed time bit cell practical speed structure linear speed cyclic structures average time cycle achieve linear speed variation open problem list structure result average time aid bits april list processing copying space complexity january
gotlieb method construction school timetable problem essentially discrete problem discrete problem feasible solution exist solution equivalent continuous problem solution set satisfy long term requirements timetable problem april smith combinatorial multi index problem conditions schedule school timetable timetable january
execution characteristics programs page demand data presented show execution characteristics types commonly programs large scale time shared software monitoring facility built supervisor data collection normal operation data analyzed results analysis presented fortran compiler interactive line file editor probability distribution functions data things cpu intervals intervals number intervals execution empirical distributions compared simple theoretical distributions exponential geometric data show paging characteristics tasks function number pages tasks core april program behavior virtual memory paging demand paging software monitor program execution characteristics compiler execution behavior editor execution behavior january
computation page fault probability program transition calculating page fault probability virtual memory operating demand paging memory sizes replacement rules order markov model program behavior assumed representation based memory states control states memory presented general sense page fault probabilities calculated replacement rules applied program represented step markov chain detailed illustrate random recently replacement rules april virtual memory demand paging replacement rule program model program behavior markov model page fault page fault probability january
simple linear model demand paging performance performance proposed automatically multilevel memory requires model patterns programs information stored memory recent experimental measurements multics virtual memory suggest approximations simple program reference model simple model effect information reference pattern effect automatic management produce single statement number memory references paging increases size paging memory resulting model easy manipulate applicable diverse problems optimum size paging memory memory usage estimating amount core memory sharing april paging demand paging memory models program models performance measurement multilevel memory systems virtual memory associative memory memory usage accounting multics january
efficient implementation variable projection nonlinear squares problems nonlinear squares frequently arise variables solved linear nonlinear part variable projection developed recently designed advantage structure problem variables separate paper slightly efficient slightly general version earlier nonlinear squares parameter estimation variable projection january
note combinatorial problem memories combinatorial analysis january
content considered artificial intelligence heuristic programming models processes music composition music theory january
quadratic search hash tables size hashing quadratic search january
scan conversion algorithms cell organized raster display raster scan graphics real time character generators previously limited characters display capabilities organization include general graphics scan conversion algorithms developed support display presented suitable interactive applications interactive applications algorithms implemented fortran cdc results obtained implementations show algorithms significantly reduce display file storage requirements cost execution time conventional raster display interactive improve response time reduce storage requirements jr graphics scan conversion raster display line drawing discrete image generation matrix displays january
routine quadratic linear programming problems january
zeros complex polynomial january
incomplete ratio january
visible surface plotting program hidden line problem graphics contour surface january
performance tests quicksort detailed performance presented acm algorithms quicksort algorithms discussed detail evidence requires comparisons author algorithms requires comparisons sort random arrays sorting place sorting sorting efficiency sorting performance tests quicksort utility sort general purpose sort sorting documentation january
optimal space allocation disk storage devices amount space required file storage amount line decisions made files decisions number requests operators computing facility reducing number turnaround time optimization model assignment files disk status presented heuristics suggested cases compute actual optimum disk analysis disk optimization disk files file systems file scheduling space allocation memory hierarchy january
dynamic memory probabilistic model multiprogramming order determine conditions dynamic main memory expression derived maximum interference process original performance alternative approaches discussed operating conditions lead improved dynamic memory memory storage fragmentation multiprogramming model probabilistic model central processor resource utilization january
construction synthetic workload general method constructing drive workload real workload real workload characterized resources characteristics real workload obtained accounting data characteristics drive workload determined matching probability density real workload drive workload drive workload realized synthetic program characteristics parameters experiments conducted determine expressions relating synthetic program parameters workload characteristics general method applied case variables cpu number activities synthetic workload jobs constructed represent workload jobs drive workload input simulation probability distribution workload synthetic workload workload characteristics january
synthesis loop current methods mechanical program verification require complete specification loop error producing program complete correct difficult machine paper discusses techniques loop classes techniques considered heuristic methods derive loop boundary conditions partially inductive assertions extraction methods input interpretations obtain classes loop evaluation interpretation program verification loop inductive assertions synthesis loop interpretations sets property extraction theorem proving january
production systems development definition syntax programming languages context free requirements interesting difficult issues syntax context sensitive requirements compatibility correspondence actual formal parameters issues block structure paper formal notation called production systems providing complete formal definition syntax practical small significant subset pl considered detailed presentation application define abstract syntax languages previous paper author syntax translation context sensitive grammars compilers formal definition pl standards january
parallel execution loops methods developed parallel execution loop multiprocessor computers array computers considered practical application design compilers computers discussed parallel computing multiprocessor computers array computers vector computers loops january
approximate method generating random variables lambda distribution generalized provide generating values random variables advantages symmetric random variable generator previously authors addition parameter problem finding parameter values fit distribution simulation monte carlo probability statistics approximations random variables random numbers distribution january
cell organized raster display line raster scan graphics displays real time character generators previously limited characters display capabilities organization include general graphics feasibility display shown minimum number patterns required read memory character generator arbitrary line synthesis process picture quality resulting patterns identical conventional raster display time constraints raster display shown satisfied typical design complex line jr graphics raster display line drawing discrete image generation matrix displays january
attribute based file organization paged memory environment high cost page implies data organization paged memory typical inverted file similar approaches multi key retrieval article analyses cost method called multiple key hashing attempts minimize approach inversion combined method exact specifications combination file data traffic characteristics formulated mathematical program proposed heuristic solution program improve simple inversion technique factor jr file organization paging retrieval inverted file multiple key hashing january
report generating january jr report generation automated systems design data processing management january
systems combinations january coding storage mapping function january
comments algorithms conversion limited entry decision tables flowcharts january johnson decision table optimal programs search january
polygon clipping family clipping algorithms algorithms polygons convex plane dimensions parts polygon volume dimensions algorithms permit clipping convex polygons represented ordered sequence vertices representation collection edges common procedure output polygons identical format vertices introduced sequence describe edge edges algorithms easily handle difficult problem detecting required clipping algorithms achieve considerable simplicity clipping separately clipping plane boundary code capable clipping polygon single boundary subsequent stage clipping store values processing output stage code clipping subsequent clipping complex practical perspective applications plane chosen clipping volume additional parallel projection serve range depth projection perspective projection method arbitrary view depth field simple fixed clipping method subsequent hidden surface computations january graphics hidden surface clipping january
bivariate interpolation smooth surface fitting based local procedures e2 january bivariate interpolation interpolation partial derivative polynomial smooth surface fitting january
computation legendre series coefficients c6 january legendre series chebyshev series january
permutations matrix similarity transformations important computational tool numerical linear algebra class sparse matrices row column permutations advantages transformation include round errors improved computation time compared standard transformations graph examines arbitrary matrix determines tridiagonal form requires arithmetic number comparisons number number linear compares standard transformation methods matrix tridiagonal form explicit tridiagonal form early occur january jr tridiagonal matrix permutation eigenvalues graph sparse matrix january
method bivariate interpolation smooth surface fitting based local procedures method designed values points rectangular plane smooth bivariate function function polynomial cell rectangular emphasis avoiding points proposed method extension method interpolation developed earlier author based local procedures january bivariate interpolation interpolation partial derivative polynomial smooth surface fitting january
fast method solving class tridiagonal linear systems solution linear systems real symmetric tridiagonal coefficient matrices constant considered proved lu decomposition floating point precision proved computed lu decomposition floating point arithmetic lu floating point machine precision real arithmetic fact reduce number floating point operations required solve linear order matrix elements operations needed entire lu decomposition takes words storage considerable savings array achieved upper lower bounds obtained terms ratio coefficient matrix constants parameters floating point number results discussed january numerical linear algebra linear systems matrices tridiagonal matrices january
syntax directed errors analysis context free languages practical approach errors developed elements bellman dynamic programming analyzer takes general class context free grammars finite string input recognition consists errors count version input relative grammar design practical aspects programming january arbitrary input strings context free grammars parsing dynamic programming stored state merging errors correction january
automatic data structure choice language high level set oriented language high level semantic objects includes finite sets ordered sets ordered paper describes structure language methods interest techniques relations inclusion established domains single proved kind established automatic choice data structures methods employed based extend techniques data flow analysis december schwartz program optimization automatic programming high level languages set languages data structure choice january
reduction method proving properties parallel programs proving parallel program property convenient statement statement program sufficient conditions obtained show assumption statement properties correctness proofs parallel greatly simplified december deadlock free reduction parallel program verification method process computation sequence january
fast linear global flow analysis abstract complete paper january global flow analysis graphs presented shown general class function graph edges worst case time bound log function operations shown programming terms number operations proportional number program loops restriction entry control structures extended larger classes function graphs time bound examples code improvement problems solved december graham global flow analysis data flow code optimization common elimination analysis information propagation flow graph programming depth search path compression january
complexity lr testing problem determining arbitrary context free grammar easily grammars lr grammars considered time complexity problem analyzed considered fixed integer considered parameter test case shown exists testing lr property size grammar question hand subject grammar problem parameters complexity problem depends strongly representation chosen specifically shown problem complete expressed expressed binary problem complete nondeterministic exponential time results classes grammars strong strong grammars december iii computational complexity context free grammars parsing lr grammars complete problems january
exponential complexity problem attribute grammars attribute grammars extension context free grammars knuth mechanism including semantics context free language syntax language problem grammar determine semantics sentences programs fact defined proved problem general computationally specifically shown deterministic problem cases exponential amount improved version knuth testing problem exponential time december attribute grammars problem context free grammars computational complexity exponential time semantics january
handling issues proposed notation paper conditions discusses requirements handling language features satisfy language features reliable proposed language features serve handling issues showing current approaches december multilevel statement error conditions structured programming conditions programming languages january
programming languages natural languages mathematics social aspects programming similar aspects mathematics natural languages applied mathematics found programming development natural languages word order based language types programming language design based general abstract constructs history artificial auxiliary languages suggested fortran cobol long time work wide high quality program literature programs general utility studies questions related program style december naur related social aspects applied mathematics language quality language development artificial auxiliary languages literature style descriptive attitudes january
note set basis problem related character sets note discusses reduction set basis problem cover problem november character sets set basis set computational complexity polynomial cover january
programming techniques purpose paper general technique history shown macros considerably computation time cases technique allowed solution previously open combinatorial problems computation terms series substantial reduction computation time solution combinatorial problem november depth search search macros combinatorial computing problem difference codes problems square january
practical syntactic error recovery paper describes recovery scheme syntax errors automatically generated high quality recovery good diagnostic information low cost previous recovery techniques summarized empirical comparisons made suggestions research paper november graham syntax errors error recovery error correction parsing simple precedence compilers debugging january
control structures program control structures history solid paper theoretical results control structures practical implications result theoretical discussed recent ideas control structures include control structures results time space limitations theorems relating relative power control structures equivalence impact theoretical results programmer importance control structures operational abstractions discussed argued evidence november structured programming control structures statements language design january
queries relational expressions square data paper presents data called square intended interactive problem solving square based relational model data shown complete bound variables required languages based relational calculus facilities query insertion deletion update tabular data syntax suggestions made alternative including syntax based english key words users limited mathematical background november iii database data relations query languages user relational data model tabular data interactive problem solving nonprocedural languages relational january
vector space model automatic indexing document retrieval pattern matching environment stored documents compared patterns search requests appears indexing property space indexing function density object space retrieval performance space density approach based space density computations optimum indexing vocabulary collection documents typical evaluation results shown usefulness model november automatic information retrieval automatic indexing content analysis document space january
rule evaluation general closed queueing networks solution closed queueing networks requires evaluation expressions number terms expressions size network direct summation show combinatorial operation count based generalization rule polynomials shown queue size obtained cost normalization constant evaluated october queueing networks queueing theory rule evaluation sums load dependent service rate january
updating standard deviation data corrigendum october january
merging parallel processors ordered sets parallel processors working paper presents merging parallel processors requires log2 log2 steps integer requires log2 steps case order constant requires log2 steps compare previous parallel merging requires log2 steps general case log2 special case october parallel processing parallel merging parallel binary insertion january
implementation structured english query language relational model data relational memory language previous papers reviewed relational data intended interactive problem solving version implemented interpreter interpreter designed minimize data operations required arbitrary query optimization algorithms designed purpose october relational model query language nonprocedural language database data structure data organization january
optimizing performance relational algebra database interface approach implementing interface support relational view data proposed basic idea automatic programming techniques interface efficiently high level query specification user relational algebra interface called designed approach detail minimize query response time space utilization performing global query optimization sort orders relations employing directory analysis maintaining page references algorithms implementing operators relational algebra presented methodology performance user query october smith relational database database optimization inverted file automatic programming query language data manipulation language high level language january
convert high level translation definition language data conversion paper describes high level nonprocedural translation definition language convert powerful highly flexible data restructuring capabilities design based simple underlying concept form enables users translation processes makes data translation simpler task convert chosen purpose language language program october data conversion data restructuring data translation database reorganization translation definition utility program programming languages nonprocedural languages january
preliminary design data structures functional approach database design introduced approach goal design derive data structure capable set queries structure models business operational program functional approach design data structures data base task group specifications automatic programming technology utilized program generate procedure generate october network model data base task group database design data structure automatic programming translation nonprocedural languages january
mechanical program analysis means analyzing program performance closed form expressions execution behavior paper discusses analysis describes simple lisp programs produce closed form expressions running time expressed terms size input paper presents reasons program analysis describes operation implementation discusses limitations september analysis programs performance analysis execution time execution behavior difference equations generating functions list processing lisp algebraic manipulation programming languages analysis algorithms january
optimal requests determining policy efficient allocation utilization set disk operational characteristics examined analytical techniques standard queueing theory disk drive characterized queueing model service time disk drive represented probability density function sum uniform distributions total response time set disk models minimized load conditions results faster devices higher utilization factors number device types utilized load specific examples combinations examined september disk drive hierarchies evaluation input output modeling queueing theory scheduling device assignment january
digital simulation population paper deals development mathematical model digital simulation fortran iv population previously developed rate expressions order study relationships mechanisms involved simulation parameters response conditions including types investigation accuracy simulation methods simulation actual population made based approximations conditions accurate simulation found general pattern growth specifically importance cycle determining patterns addition study usefulness digital simulations examinations planning involving examinations september digital simulation mathematical modeling population mechanisms simulation modeling impact planning january
multidimensional binary search trees associative searching paper multidimensional binary search tree tree search space data structure storage information associative tree defined examples shown storage requirements significant advantage structure single data structure handle types queries efficiently utility algorithms developed average running times record file insertion log deletion root deletion random node log optimization logarithmic performance log search algorithms partial match queries keys maximum running time queries observed average running time log algorithms tasks presented handle general intersection query main focus paper theoretical trees applications examples potential september associative retrieval binary search trees key attribute information retrieval queries partial match queries intersection queries binary tree insertion january
multiprocessing garbage collection algorithms multiprocessing garbage collector presented discussed simple case processors performing lisp list operations performing garbage collection examined capabilities processor defined communication complete procedures garbage collection standard list processing primitives presented explained attention problems list cells processor operating primary list processor run processor list storage complex cases involving list processors garbage collection processors briefly discussed september jr garbage collection storage storage allocation multiprocessing synchronization semaphores parallel processing lisp list processing free storage pointers data structures processor january
constants corrigendum august january
comparison simulation event list algorithms corrigendum august january
combining decision rules decision table techniques minimizing logic circuits applied simplification decision tables combining decision rules method equivalent method finding prime decision rules rule occur low frequency rule simplify decision table objectives merit consideration optimizing decision table reducing machine execution time reducing time reducing required machine memory reducing number decision rules decision table human shown objectives methods objective decision rules combined objective compared potential objectives methods august method prime minimization logic circuit boolean method coding decision tables sorting january
multiple processing full word instructions method parallel processing data items ordinary full word instructions processing requires operations execution technique processing small data items characters august processing character processing data january
consecutive storage relevant records redundancy paper studies properties class file organizations records relevant query stored consecutive storage locations organizations redundancy theorems provide tools reducing redundancy organizations developed obtained application theorems compared query inverted file organizations organization minimum redundancy developed queries sets keys august consecutive retrieval storage file records query redundancy key january
comments paper august smith binary coded decimal digits decimal data storage data compression codes variable length codes january
interactive natural language interactive programming systems commands give programmer line instruction systems commands argued easy make commands significantly requests natural language program provided natural language august interactive programming time sharing systems natural language processing assisted instruction january
updating standard deviation data august standard deviation january
commands formal derivation programs called commands introduced building block alternative constructs nondeterministic program components activity final state necessarily determined initial state formal derivation programs expressed terms constructs calculus shown august dijkstra programming languages sequencing primitives program semantics programming language semantics case construction termination correctness proof derivation programs programming methodology january
deterministic parsing grammars methods describing syntax programming languages ways flexible natural conventional descriptions considered methods context free grammars rules syntactic ambiguities shown efficient lr parsers constructed directly classes specifications august johnson programming language specification parser generation translator writing systems syntax analysis lr parsing parsing grammars january
external storage fragmentation produced fit fit allocation strategies published comparisons external fragmentation produced fit fit memory allocation simulation series experiments performed order obtain data relative performance fit fit understanding reasons underlying observed differences time memory product fit fit generally percent small size request population effect allocation efficiency exponential distributions requests fit fit normal uniform distributions exponential distributions ways fit fit fit fit fit end memory large blocks end sufficient space large requests results simulation experiments hypothesis relative performance fit fit depends frequency request coefficient variation request distribution greater approximately equal fit fit august storage fragmentation dynamic memory allocation fit fit january
employment women industry july women employment programmers systems analysis operators machine operators january
note hash linking july hash search address space extension implicit pointers monitor conditions january
determining minimum area rectangle arbitrary closed curve paper describes method finding rectangle minimum area arbitrary plane curve contained method interest optimum layout problems consists determining minimal convex polygon curve selecting rectangle minimum area capable polygon theorems introduced show side minimum area rectangle edge polygon minimum area rectangle convex polygon minimum area rectangle curve july curve optimum layout optimum minimum area rectangle january
concept design structured systems paper deals design structured programming systems method evaluating cost requiring programmers work abstraction real machine number examples hardware software method july hierarchical systems bottom design levels abstraction synchronization primitives january
restriction language grammars natural language past years number systems analysis natural language sentences based context free grammars context free grammar set parse trees sentence group restrictions tree order valid sentence analysis grammar increased efficient representation essential development paper presents programming language designed specifically compact statement restrictions natural language grammar based ten years experience parsing text sentences comprehensive english grammar linguistic string project syntax routines relations found computerized natural language analysis language current implementation linguistic string parser july natural language parsing grammar programming languages january
large based operating paper describes internal structure large operating set sequential processes processes means semaphores extended semaphores queue semaphores number parallel processes explained proved free deadlock design principle alternative dijkstra hierarchical structuring operating systems project management performance discussed operating large multiprogramming july processes operating semaphores applications queue semaphores deadlock hierarchical structuring multiprogramming operating structure structuring parallel processes primitives code project management time schedule debugging project planning project scheduling reliability program proving coroutines correctness program maintenance software paging january
multiprogramming systems step step approach model dynamic behavior evaluate performance computing systems proposed based technique variable concept approach order identify multiprogramming paging systems operations ii critical computing states analysis complete definition set july multiprogramming paging performance evaluation levels hierarchy networks queues january
improved event scanning mechanisms discrete event simulation simulation models large complex real world applications time problem part difficulties slow stochastic convergence additional problem fact significant amount time required future events proper sequence paper presents method significantly reducing time scanning future event lists discrete event simulations models presented improve effectiveness events list scan problem june discrete event simulation simulation event scanning mechanisms january
sorting june merge sorting computational complexity data modeling computing models binary comparisons january
addition arbitrary base radix conversion paper presents generalization programming technique numbers represented radix including mixed radix stored digit sufficient size radix conversion required numbers stored display format applications cobol mix sums discussed june addition decimal arithmetic arbitrary radix arithmetic radix conversion mix arithmetic cobol display arithmetic mixed radix arithmetic january
linear space computing common problem finding common strings solved quadratic time space presented solve problem quadratic time linear space june common string correction editing january
efficient string matching aid search paper describes simple efficient occurrences finite number string text consists constructing finite state pattern matching machine pattern matching machine process text string single pass construction pattern matching machine takes time proportional sum lengths number state made pattern matching machine processing text string independent number improve speed library search program factor june string pattern matching search information retrieval text editing finite state machines computational complexity january
simplified scheme buddy simplified scheme buddy requires tables calculations additional bits buffer presented june buddy dynamic storage allocation buddy january
threaded code efficient arrangement interpretive code related bell notion threaded code requires space machine independent implementations june threaded code code generation january
significant event simulation paper compares method simulation organization called significant event method called method examples traffic models significant event method found efficient method low levels interaction efficient high levels simple mathematical model relative running time methods developed model aids simulation methods experiment concluded significant event method simulation systems computational efficiency sufficient importance june simulation organization event simulation simulation significant event simulation january
cost oriented data set allocation storage hierarchies data set allocation today multilevel storage systems based decisions desirable obtain optimal solution allocation problem number parameters involved makes forward solution situation find set assumptions simplify problem greatly provide basis significant cost elements paper presents allocation step considers significant detailed costs utilization data storage data data improvement present accurate aid problems data set allocation storage configuration device designs june data set allocation hierarchical storage storage configuration data data storage allocation analysis january
generated pictures quality generated images dimensional depends technique objects ray depends part method modeling object determines hidden surface methods object modeling hidden surface removal strongly techniques methods object modeling related hidden surface algorithms presented human fundamental considered development rule quality increased generated images june graphics graphic display hidden surface removal january
generation cycles graph set basic cycles june basic cycle cycle graph january
heuristic problem solving design equipment designer problem perform simple design tasks designs equipment task chosen simple defined characteristic design tasks architecture engineering planning natural resource management space planning tasks manipulating dimensional representations objects create feasible optimal solutions problems involving topological constraints paper describes extensive tests performed program heuristic problem planning phase planning process give sense diagnostic procedures difficulties actions difficulties convex polygon representation accurately describe objects layout representation topological constraints tested design easily applied problems slow limited scope ideas general search methods achieve task specific information planning diagnostic procedures actions selective alternative generators artificial intelligence aided design design synthesis diagnostic search heuristics planning problem solving representations search strategies space planning representations january
syntactic detection applications incorporating linear approximation tabular parsing techniques parameters serve identify context accurate measurement shape sufficient speed line real time processing application demonstrated detection linear approximation context free grammar bottom parsing january
programming corrigendum january
problem list public policy issues computers economic social implications public computing january
shortest paths networks shortest paths january
note lu factorization symmetric matrix evans symmetric matrices factorization test matrices matrix inversion systems january
solution equations january
visible surface plotting program january
visible surface plotting program january
ten subroutines manipulation chebyshev series january
basic cycle generation graph basic cycles fundamental cycle spanning tree matrix january
analyzer english paper describes working analysis generation program natural language length input core choice semantic patterns based call semantic density syntax oriented linguistic approaches theorem proving approaches understanding problem artificial intelligence computational linguistics machine translation understanding natural language processing semantic semantic density january
analysis performance inverted data base structures architecture data base systems hierarchical level level framework inverted data base file organization analyzed implementation oriented aspects inverted directory viewed large data base inversion derived estimate average access time read storage requirements interaction data base content characteristics logical complexity queries machine timing specifications identified order effect performance presented conjunction index selection criteria determine optimum set index keys data base architecture inverted file organization data base performance measurement secondary index organization information storage retrieval query answering january
copying cyclic list structures linear time bounded workspace bounded workspace copying arbitrary list structures operates linear time require bits previous bounded workspace copying algorithms achieved time bits log time restriction section memory method applicable fixed variable size nodes fisher list processing copying linear time space complexity january
comparison simulation event list algorithms algorithms considered schedule events general purpose discrete simulation algorithms based end order tree structure event linear list algorithms tested set typical stochastic scheduling distributions chosen show advantages limitations algorithms end order tree shown replacement current simulation languages list concept require adaptive routine employed general purpose performance study april simulation time flow mechanisms event list simulation time flow mechanisms event list simulation executive event scheduling routine discrete simulation sorting january
storage blocks buddy simple scheme determination location block storage relative blocks scheme applicable buddy type storage allocation systems april dynamic storage allocation buddy generalized sequences january
modification binary relations computing binary relation represented boolean matrix similar faster sparse matrices computers paging environment april jr matrix directed graph boolean matrix binary relation january
quadratic hash method table size prime number previous work quadratic hash methods limited case table size prime number results derived numbers shown numbers square component full period integer coefficient quadratic hash functions april quadratic search hash code scatter storage table size january
synthesis bounded technique presented class solid objects stored synthesis primitive solid added algorithms perform addition practical designers technique advantage operations readily terms easily short sequences operations complex bounded april computational geometry aided design graphics components shape synthesis dimensional modeling january
maintenance list class timetable problems principal components procedures solution class timetable problems maintenance list list maintenance methods based conditions existence solution general framework conditions specific sets conditions april smith combinatorial conditions list schedule school timetable timetable january
weighted buddy method dynamic storage allocation corrigendum april january
april january
function real argument s22 april january
networks higher education economic political factors study presents results survey networks higher education conducted major networks identified major networks included state network university state university network educational research information universities computation center network depth studies conducted based operating networks number factors identified consideration developing networks finally recommendations advanced development networks higher education future april networks higher education january
solution problem conditional statements report discusses problem introduced problem solved operations introduced dijkstra conditional statements examination proof shows established strong restrictions restrictions eliminate programming techniques dijkstra introduction concept paper solution problem discusses generalized operators suggested operating systems operating processes process synchronization primitives january
eigenvalues normal matrices corrigendum january
discrete squares polynomial recurrence relation orthogonal polynomials widely discrete squares data fitting classical numerical properties presented improved performance explained orthogonal polynomials data fitting squares recurrence relation orthogonal polynomials january
computing elements inverse sparse matrix recursive computing inverse matrix lu factors based relationships examined formulas relationships derived computational costs developed general comments application stability made sparse matrices triangular factorization elements inverse tridiagonal matrix january
sequential access method alternative index sequential keys direct access method sequential access method information retrieval january
high level languages philosophy language design january
finding elements m1 floyd selection january
expected time bounds selection selection presented shown efficient average number comparisons numbers lower bound percent formula derived floyd selection computational complexity january
programming language iv existing languages designed programming iv syntax language based algol extended programmer explicitly parallelism terms word vectors paper describes characteristics goals philosophy language discusses problems parallel iv programming language parallel computation parallel architecture january
typesetting mathematics paper describes design implementation typesetting mathematics language designed easy learn people mathematical mathematics typesetting experience language rules fewer typical expressions size line drawing mathematical conventions automatically input sum produces formula syntax language small context free grammar compiler compiler make compiler language typesetting commands output produced terminal forward reverse half line directly text programs text mathematics handled simply paper authors typesetting compiler compiler graphics text processing january
matrix reduction efficient method paper describes efficient method reduction binary matrices arise school time problems development generalized fit complete process compact data representation efficient processing techniques advantage previous knowledge matrix designed structured program readily coded high level low level programming language choice practical tests method shown good basis hoare binary matrices matrix reduction set school timetable construction structured programming january
finding array picture processing pattern recognition curve detection line fitting january
minimal spanning tree clustering method january
elementary circuits graph january
exact probabilities tables january
jacobi polynomials january
square january
state space problem reduction theorem proving relationships paper suggests relationship state space problem reduction representations presents formalism based multiple input multiple output operators basis types representations manner representation language recognition problem based parsing method representing problems order logic inference employed resolution based theorem determines set state mode problem reduction mode presented concepts problem reduction theorem proving terminology noted relationship problem reduction input resolution linear resolution discussed artificial intelligence state space representation problem reduction representation theorem proving language recognition january
sentence conceptual base model natural language based underlying language free representation meaning program based model produce sentence demonstrate understanding respect context generator operates conjunction natural language analyzer combined memory inference model generating sentences meaning structures program employs information retrieval capabilities memory model model diverse classes linguistic knowledge include tests conceptual properties stored information relating conceptual syntactic stored word sense dictionary surface knowledge stored formal grammar artificial intelligence natural language processing language generation models processes semantic representation january
monitors operating structuring concept corrigendum hoare january
order approximation optimal interval corrigendum january
analysis memory systems model memory systems presented analysis model monte carlo simulation discussed simulations performance structures schemes instruction data requests memory performance measured determining distribution number memory modules operation memory cycle important separately instruction data requests memory substantially increase average number memory modules operation memory cycle results simulations analytical study displayed structures jr memory systems modular memory systems memory performance analysis buffer conflict buffer simulation monte simulation january
updating standard deviation data sample set data fit data constant function computational method based matrix formulation transformations sample standard deviation data procedure numerically stable require storage data methods weighted data data removal presented updating square standard deviation process requires square roots january standard deviation squares transformation updating estimates data january
accuracy stability properties linear formulas paper concerned stability accuracy linear step formulas depending parameters emphasis numerical solution ordinary differential equations upper bound derived order accuracy stable formulas criteria stability shown arbitrary stability implies conditions stability stability meaning roots satisfy stability implies stability parameter classes formulas stability implies stability january equations linear formulas order accuracy stability stability stability january
storage efficient representation decimal data decimal digits represented bits computers digits compressed bits digits bits simple based fixed length combination variable field length half cases compressed code results conventional code simple removal redundant bits long decimal message digit blocks separately compressed result asymptotic minimum length percent hardware requirement small january binary coded decimal digits decimal data storage january
programming structured programming proved important methodology systematic program design development structured programs identified function expressions algebra functions algebraic properties function expressions permit expansion reduction nested independently environment modeling program program execution finally structured programming characterized terms selection solution elementary equations defined algebra functions solutions general formulas involving single parameter display entire correct structured programs january structured programming algebra functions program correctness january
paper study matrices routines january matrix minimization january
elementary tensor products elementary tensor product linear transformations years paper short easily proof results points interesting combinatorial proof january elementary tensor products linear transformations january
eigenvalues normal matrices problem considered give bounds finite simple multiple eigenvalues matrices bounds terms eigenvalues matrix terms bounds derived shown set matrices january van eigenvalues normal matrices january
numbers matrices discussion functions entries square matrix related determinant theorem alternatives bound condition numbers linear systems systems january matrices eigenvalues condition numbers error analysis january
stability gauss elimination stability gauss partial solution general systems linear equations commonly shown general error solution comparable gaussian elimination partial back substitution gauss solution greater gaussian elimination solution january gauss gaussian elimination back substitution backward error analysis bounds error solution bound january
constants constants methods computing part development mathematics account methods made elementary methods material teaching purposes relevant interesting material methods developed purpose evaluating constants problems january elliptic functions euler transformation january
lines work character algebraic methods theory demonstrated results values vector necessarily ordered generalization order unit application operator properties positive operators january matrices numerical range vector january
computing field term professional means things people general technical social standards professional term generally applied definition computing professional types institutions academic industry government professional society status computing institutions examined noted recommended suggested analysis professional status universities industry specifically make improvements computing achieve professional status january professional aspects educational programs industry attitudes professional certification january
structural pattern recognition general parsing general parsing application structural pattern recognition wave importance variation structure syntax driven analysis applied good results measure structural variations parsing compiler compiler user application specific information data general applicable december structural pattern recognition parsing analysis january
aided analysis design information systems paper describes aided analysis design development integrated management material command support activity aided analysis consists set procedures programs specifically designed aid process applications software design selection performance evaluation major components problem statement language problem statement analyzer generator alternative designs performance statement requirements written accurately defined systems analyzed problem statement analyzer problem definition additional information order create complete problem definition analyzed problem statement form systems optimization design program generation alternative specifications program modules logical database structures december jr jr aided analysis information systems logical design problem statement language problem statement analyzer physical design accurately defined systems systems optimization design january
science engineering research study science engineering research study briefly organization schedule study reference subject area members committee identified december science research engineering research national research study january
programming languages december january
high level binding low level easy implement scheme compiler complex data types separately compiled modules scheme designed work existing link editor linking run time errors caused static errors linking time november separate compilation binding linking strong january
optimal reorganization distributed space disk files database organizations cost database increase due structural caused database access costs reduced basic problem proper performance storage costs reorganization costs paper considers optimum points database disk file organization distributed free space cost function describing costs due physical defined function minimized obtain optimum reorganization points numerical examples based characteristics existing disk storage devices november smith disk file free space retrieval insertion reorganization january
consistency database database systems users access shared data assumption data consistency constraints paper concepts transaction consistency schedule shows consistency requires transaction request argued transaction logical physical subset database subsets implementation consistency condition suggested november gray consistency database transaction january
interference multiprocessor systems memory corrigendum november smith january
experiments text file compression compression data files viewed strings characters presented method general english pl digital data consists analysis program algorithms encoding string slightly earlier proposals analysis program attempts find optimal set codes representing file algorithms operation compared parameters algorithms obtain high degree compression sample november text compression data file codes encoding comparison algorithms january
design implementation table driven interactive diagnostic programming highly interactive diagnostic compiler interpreter programmers execute simple programs graphics display terminal complete syntax checking semantic analysis performed program analysis performed character character feature ability automatically errors compile time run time errors automatically student find error components table driven reduce space needed implementation increase flexibility students learn fortran pl conjunction assisted science november interactive programming table driven compilers error correction interpreters debugging assisted instruction science education january
cobol control sample set cobol programming standards offered standards code developed structured form data control structures require syntax existing cobol language fact typical limited subset cobol standard standards proved extremely valuable practice reduced cost time produce large software systems multiple environments november cobol structured programming software development program standards january
standards computing general part material provided acm reference made data fact computing november standards case standards criteria standards standardization january
status women academic science results survey women students science years presented analysis data effective action programs graduate degree programs needed number women employment science employment women graduate students october jr women graduate students undergraduate students academic employment science degree programs action january
improvement computation linear precedence functions october syntax analysis precedence functions boolean matrices january
series statistical programs october analysis variance analysis tables data analysis analysis factor analysis graphics regression time series transformations january
interactive skeleton techniques motion key frame significant increase capability motion key frame achieved skeleton control technique develop complex motion sequence figure representation image control sequence drive image sequence simplicity figure image high level interaction design stage compatibility basic key frame technique permits skeleton control applied components image sequence require october interactive graphics generated key frame interactive skeleton control figure january
drawing pictures solid objects surfaces drawing pictures dimensional objects surfaces made surfaces emphasis calculating surfaces scheme surface intersection curve represented set coefficients parameter parameter represents points easily scheme find points fourth order intersection curves equations order methods type discussed surface hidden surface removal october graphics hidden surface removal surface intersection curves january
hierarchical geometric models visible surface algorithms geometric structure inherent definition dimensional objects environments define relative motion assist solving problems systems producing pictures extension traditional structure information geometric hierarchy significant improvements current techniques range complexity environment greatly increased visible complexity fixed upper provided amount detail presented clipping fast logarithmic search parts environment field view fourth frame frame clipping define graphical working set total structure present primary store access visible surface finally geometric structure suggests recursive visible surface computation time visible complexity october clark visible surface algorithms hidden surface algorithms hierarchical data structures geometric models january
generated images developed images bivariate surface paper describes extensions areas simulation models coordinate key mapping patterns surface pattern picture element computed weighted average regions pattern definition function shape size function chosen digital signal processing theory accurate computation surface normal picture element simulation amount light similar manner mapping added obtained mapping examples images techniques included october graphics graphic display hidden surface removal january
addressing algorithms corrigendum september january
analysis replacement semi markov model corrigendum september
faster retrieval context trees corrigendum context trees provide convenient storing data viewed hierarchy contexts note presents previous context tree retrieval algorithms based typical context relative data speed retrieval retrieval position previous retrieval auxiliary structures built make search rapid algorithms addition deletion data garbage collection outlined september context trees frame problem variable data structures january
efficient incremental automatic garbage collector paper describes solving storage problem lisp storage automatically require programmer give items longer reference count scheme structures copying scheme storage users proposed algorithms designed work systems multiple levels storage large virtual address space fact cells reference counts accurate storage transaction file reference counts multiple reference table count items september storage management garbage collection lisp january
efficient generation binary gray code applications algorithms presented generate bit binary gray code fixed code algorithms efficient time required generate element current constant applications generation combinations things time integers permutations discussed september gray code combinations subsets combinatorial computing january
recursion analysis compiler optimization simple method detection recursive procedures presented compiler optimization implementation considerations discussed modification improve optimization analysis determine subset values assumed variables small discrete set values common parameters variables values procedure type september recursion compiler optimization january
weighted derivation trees nodes weighted derivation tree functions vocabulary context free grammar presented constructing optimal derivation tree structure weighted derivation tree addition correctness established method applied problems involving probabilistic parsing combinatorial optimization september derivation tree parse tree probabilistic grammar structural ambiguity combinatorial optimization january
upper bounds selection worst case minimum number comparisons complexity selection problem considered upper bound bound standard generalization method range application generalization compares recent september selection problem algorithms comparison problems computational complexity upper bounds worst case analysis january
analysis real time garbage collection real time garbage collection operations list processor long times garbage collection requires performing garbage collection processor parallel list processing operations single processor time shared algorithms list structures manner presented analyzed determine sufficient conditions list processor collector techniques shown require processing power regular garbage efficiently average behavior program shown equal worst case performance sufficient conditions suitable measuring typical behavior september garbage collection storage list processing lisp time sharing multiprocessing parallel processing real time data structures analysis algorithms january
insertion technique sided height balanced trees restriction height balanced binary trees presented restriction reduces memory requirements half bits node fast search capabilities cost increased time requirements nodes august balanced binary search trees january
protection operating systems model protection mechanisms computing systems presented argued problem protection systems model determine situation subject object restricted cases shown problem determine configuration general assumptions situation implications fact discussed august protection protection operating turing machine january
designing surfaces experimental aided design free form surfaces dimensions surfaces represented basis splines principal features surfaces line head display designed aid dimensional points surfaces interactions surfaces real time mathematical knowledge user examined features part practical designing space forms august clark real time graphics aided design picture processing splines displays january
semantics programming languages paper tutorial introduction theory programming language semantics developed application theory formal language specification demonstrated applications language considered loop elementary definition notation methodology approach semantic concepts environments introduced model classes programming language features underlying mathematical theory computation due outlined finally paper presents formal definition language august semantics programming language environment store theory computation higher order function recursive definition loop january
tools philosophy software education paper describes set tools philosophy teaching software found past years tools include programs compilers monitor basic concepts relevant student project activities august software education programs student january
applied event driven mechanisms july discrete event simulation event scanning mechanisms priority queues january
buddy variation disk storage allocation generalization buddy storage allocation set permitted block sizes size satisfy condition size size size integral function makes logical storage blocks physical storage blocks july buddy dynamic storage allocation january
compressed paper presents data structure called compressed information retrieval systems underlying tree structure parameter fields nodes large key fields bit long analysis part paper shown collection keys retrieval time measured terms bit key order storage requirement order log2 bits improvement storage requirements retrieval time achieved cost flexibility structure updating costs increased analyzed data structure methods static discussed july data structure database tree retrieval time storage requirement keys january
sampling gamma distribution paper describes method generating gamma appears recently suggested method large shape parameter cost computation proportional method proportional small method suggested methods recently suggested methods large method suggested technique july gamma method sampling january
synthesis decision rules decision tables effective tool record logic processes automated result structure complete decision tables sets decision rules purpose paper provide procedure decision rules provide aid developing structure complete decision tables july decision rules decision tables logical tables logical design design specification language january
distributed packet switching local networks communication digital data distributed computing packet mechanism provided systems viewed local networks shared communication facility medium central control coordination access packet distributed controlled statistical switching distributed packet address recognition design principles implementation based experience operating nodes model estimating performance packet error controlled communication included july networks packet switching multiprocessing distributed control distributed computing communication statistical january
symbolic execution program testing paper describes symbolic execution programs normal inputs program numbers symbols representing arbitrary values execution normal execution values symbolic formulas input symbols difficult interesting issues arise symbolic execution conditional type statements called symbolic execution program testing debugging programs written simple pl style programming language includes standard debugging features ability prove things symbolic expressions simple program testing program discussion relationship symbolic execution program proving included july symbolic execution program testing program debugging program proving program verification symbolic interpretation january
formal verification parallel programs formal models parallel computation presented abstract conceptual model parallel program model model control data states model includes capability representation infinite set control states allowing instruction pointers processes executing program induction principle presented control data state sets place variables observed correctness conditions expressed enumeration set control states examples presented induction principle demonstrate proofs mutual exclusion shown assertions oriented proof methods special cases induction principle special case assertions method called parallel place assertions shown incomplete deadlock presented concept introduced yields extension deadlock problem floyd technique proving termination discussed extension program model process local variables permits shared global variables correctness forms implementation discussed included work previous work logical formulas july parallel program correctness verification assertions deadlock mutual exclusion january
technology center management proposed graduate professional programs science information systems made strong case information systems administration courses proposed acm curriculum committee education management graduate professional programs information systems paper report technology center management offered past years suitable graduate professional programs information systems graduate professional programs science july education information systems administration center management performance january
permutations combinations june coding systems storage mapping functions january
multiprocessing garbage collection corrigendum june jr january
efficient list moving constant workspace efficient presented moving arbitrary list structures storage program variables required original list original list mark bits pointers pointers original superior execution speed previous algorithms problem variations extensions discussed june clark list moving list copying lisp space complexity constant workspace january
synthetic approach decision table conversion previous approaches problem automatically converting decision tables programs based decomposition stage condition selected testing smaller problems decision tables condition created optimal program respect average execution time storage space implicit enumeration decision trees technique bound approach paper dynamic programming optimal decision tree program created approach efficiency optimal program increased substantially generation optimal programs decision tables ten conditions june decision tables decision trees dynamic programming optimal programs january
lists edge edge reference list structure pair pointers nodes reference requires additional space yield efficient algorithms circular link list redundant list edge list link edge references nonrecursive lists cells double link lists june list processing circular linked cell january
process determination addresses variable length addressing presented assignment instruction addresses conditions length instruction function distance instruction exists criterion implies subject addressing constraints number long instructions case total code length minimized minimizing assigned address point program suitable arbitrary program structure choice optimization criteria june variable length addressing paging january
interference multiprocessor systems memory paper memory interference caused processors simultaneously memory modules results computed simple model derived relative degree memory interference size increases model behavior yields approximate results simple model suggests results valid larger class models including real systems simple model tested measurements program behavior simulations systems memory references real programs model results provide good performance expected real type june smith memory memory interference multiprocessing memory trace driven simulation january
addressing algorithms paper number rules suggested design record addressing algorithms discusses applicability rules large guidelines selecting transformations overflow techniques loading factors sizes loading order considered attention common heuristics determining primary secondary sizes mathematical model explicitly considers storage device characteristics time space cost effect design parameters costs specific design presented solved june data management file retrieval searching addressing techniques hashing functions resolution loading factor size heuristic design rules january
production employment ph science june january
analysis replacement semi markov model analytical model presented estimate performance page fault frequency replacement model program behavior represented stack distance model replacement represented semi markov model models parameters page fault interval distribution probability number distinct pages page fault interval determined models evaluate parameter values permits study performance replacement simulating page fault events page reference event significantly reduces required computation time estimating performance replacement semi markov model simulation replacement january
optimal variable space page replacement criterion comparing variable space page replacement algorithms presented optimum page replacement called shown optimum respect criterion results simulating denning working set page partitioning replacement algorithms virtual memory programs presented demonstrate improvement variable space algorithms demand paging performance measurement multilevel memory systems virtual memory working set page replacement algorithms optimal page replacement january
characteristics program term subset program segments phase execution program behavior characterized terms sizes paper concept made explicit formal definition phase reference behavior mechanism detection actual reference strings definition existence hierarchy time definition examples actual programs empirical data sample production algol programs display distributions sizes results discussed terms implications modeling program behavior memory management virtual memory systems program behavior memory management january
properties parallel programs approach method proving number properties parallel programs presented hoare set axioms partial correctness strong cases paper powerful sense complete partial correctness auxiliary variables added parallel program aid proving correct information partial correctness proof prove properties mutual exclusion deadlock program termination techniques properties presented illustrated application problem structured multiprogramming correctness proofs program verification concurrent processes synchronization mutual exclusion deadlock january
proving monitors interesting scheduling sequential properties monitors proved state variables record monitor history defining extended proof rules signal operations techniques defined discussed applied examples prove properties upper bounds queue lengths behavior monitors correctness proof rules variables scheduling bounded buffer semaphores disk head january
hierarchy family operating systems paper describes design philosophy construction family operating systems shown concepts level hierarchy functions family members share software result implementation run time modules level incremental machine design data type address space virtual memory january
operating design main features general purpose operating developed cdc presented good points discussed features design capabilities protection organization sequence building facilities provided earlier problems maintaining protection levels added memory hierarchy problems discussed solution operating protection capabilities domains memory hierarchy january
security practice security software hardware mechanism access correctness security pdp proved paper describes technique step proof formal specification program respect axioms secure verification correctness security formal specification protection january
model secure information flow paper mechanisms secure information flow mechanisms examined mathematical framework suitable requirements secure information flow security classes central component model structure derived security classes semantics information flow properties permit security requirements existing systems facilitate construction mechanisms security model view systems information flow enables classification security objectives suggests approaches construction automatic program certification mechanisms secure flow information program denning protection security information flow security class program certification january
logical analysis programs present systems verification programs incomplete intermediate inductive assertions provided user termination programs solution problems paper suggests logical analysis programs program part paper techniques automatic generation part criteria check simultaneously correctness including termination part examines implications approach automatic diagnosis correction logical errors april logical analysis program verification correctness termination automatic debugging january
paging corrigendum april january
language analytic geometry conversational programming language analytic geometry aspects implementation language flexible definition geometric objects elements parameters displays results capability geometric figure collection parameters parameters characteristic consists possibility language design user oriented languages specifically designed easy learn natural language geometry april interactive programming problem oriented languages graphics interpreters analytic geometry january
comparative evaluation basic basic language terms usage scope usage features article compares ten current basic earlier proposed standard minimal basic comparison features computational comparison computation times processing costs april basic interpretive language summary january
development legal protection programs april software software legal protection software january
resolution privacy protection database systems privacy protection database systems control information user database paper concerned independent dimension privacy protection control user allowed information database ability condition information intended called resolution privacy protection practical importance resolution demonstrated examples discussed shown resolution achieved involves change traditional approach process user database interaction appears database amount control internal behavior users programs model user database interaction control developed protection database protection programming languages privacy security resolution privacy interaction january
program data flow analysis procedure global data relationships program static analysis methods paper procedure determines definitions possibly node control flow graph program definitions edge graph procedure interval ordered edge data structure graphs program optimization data flow analysis flow graphs algorithms compilers january
policies batch batch users classes service formulated semi markov decision process users minimize expected loss optimal policy users queues control policy single control number queue user class user queue control number queue user class paper control numbers lower upper bounds control numbers queues derived priority queues semi markov process price scheduling operating january
science empirical symbols search symbols search science science empirical turing artificial intelligence intelligence list processing heuristics problem solving january
fast division technique constant fast division constant presented method proved implemented binary machine directly hardware mathematical presented performance measures constant division algorithms bit memory january
paging natural optimal group records pages independent reference model paging organization optimal recently miss ratio minimized recently independent reference model storage organization record allocation january
stochastic evaluation model database organization data retrieval systems experimental work large scale data retrieval systems due difficulty cost paper discusses simulation model data retrieval effect significantly reducing cost research model designed estimate retrieval workload alternative data retrieval systems data retrieval systems organized database organizations including inverted list threaded list cellular list organizations combinations systems effectiveness methodology demonstrated model study effect database organizations data retrieval systems impact query complexity analyzed database architecture database performance evaluation list threaded list cellular list information retrieval database organizations query complexity stochastic model monte carlo simulation january
application heuristic search methods edge contour detection paper presents method detecting edges pictures properties edge embedded figure merit edge detection problem problem minimizing figure merit problem represented shortest path problem graph solved graph search algorithms relations representation minimization problem dynamic programming approach discussed showing graph search method lead substantial improvements computing time heuristic search methods computing time amount picture experimental results show information shape contour object embedded figure merit allowing extraction picture objects picture processing pattern recognition edge detection contour detection contour optimization problems dynamic programming shortest path heuristic search methods problem solving methods january
permutation enumeration permutation algorithms classical permutation enumeration algorithms special cases requiring additional computation permutation generating permutations algorithms attribute special cases occur permutations algorithms produce permutation single algorithms rules generating permutation simple performance tests execution assignment statements comparisons arithmetic operations array references shown algorithms compared boothroyd implementation implementation johnson permutations loop free algorithms january
organizing sequential search heuristics paper examines class heuristics maintaining sequential list approximately optimal order respect average time required search element element fixed probability independent previous performed move transposition heuristics shown optimal constant factor transposition rule shown efficient empirical evidence suggests transposition fact optimal distribution search probabilities searching organizing list processing heuristics january
semantic evaluation left paper describes attribute grammars definition programming languages compilers formal definition attribute grammars discussion important aspects included paper evaluation semantic left derivation tree program condition attribute grammar semantics program evaluated single pass derivation tree discussed left general attribute grammar explained terms grammar describes scope rules algol practical questions relative efficiency evaluation schemes ease attribute grammar programming language left evaluation scheme discussed attribute grammars semantics programming languages semantic left parsing compilers semantic evaluation semantic conditions january
study errors error error diagnosis cobol paper data cobol error frequency correction errors student oriented compilers improvement teaching programming language cobol studied economic importance usage error including design lack research types errors identified study error types found errors runs cobol students error density high percent types contained percent total frequency implies high potential effectiveness software based correction cobol high frequency errors error implies minimal error design percent cobol error previous implies cobol algorithms word usage error implies minimal interference usage words percent error diagnosis found feedback optimal users learning user cobol january errors programming error correction cobol programming language errors error analysis error error frequency spelling errors syntactic errors learning programming teaching programming january
information reference coding items business systems identified reference codes data codes file keys data processing business systems large integrated files database codes control future extension maintaining correct program action principles coding discussed logical data items reference code framework shown set information model january data file reference code systems analysis information modeling database january
performance height balanced trees paper presents results simulations performance height balanced trees shown statistic trees avl trees function size tree time search item tree sufficiently large trees execution times procedures maintaining trees independent size tree average required insertion average nodes property average required deletion average nodes property execution times procedures maintaining trees independent size tree average number nodes operation order property trace back cost maintaining trees increases analytical experimental results show cost maintaining trees function discussed january trees balanced trees avl trees information storage retrieval searching january
quadratic adaptive routing algorithms analytic models store forward communications network constructed find optimal message routing illustrate state adaptive routing models show adaptive routing satisfy conditions optimal routing adaptive routing direct path impact current routing decision future state network form conditions suggests modification adaptive result modification requires substitution quadratic term linear routing table network node simulation results presented theoretical analysis simple network january routing algorithms adaptive routing quadratic routing routing store forward network distributed network network message switching january
disk scheduling comparison scheduling empirical model disk accesses model disk accesses based published measurements developed model show highly conditions scheduling superior scheduling sense lower queue length simple sequence presented january disk scheduling scheduling january
study line overhead form extent effect communication line overhead considered source head levels hierarchy characteristics level summarized line efficiency models studied measurements line efficiency presented measurements overhead network similar results derived recently proposed network compared current january communication networks communication measurement packet switching performance evaluation efficiency resource sharing january
computers american local computers electronic data processing major technological operations american local government paper substantial variation larger local rate technology level support provide automated applications central question differences extent computers tested factors data identify local government higher levels significant impact distribution control decisions political values government important factors include measured applications external support computing finally paper suggests framework key technological december technological utilization american local government government computers government computers december
methodology interactive service measurement measurement methodology applicable teractive service primary purpose external user oriented performance frequently measurement techniques network measurement employed external measurement tool data analyzed methodology leading figure merit evaluation results included december teractive service measurement performance external measurement methodology measurement model network measurement measures figure merit december
language formal problem specification language behavior communicating parallel processes specifications ts order events computation occur language write specifications readers writers problem priority readers writers problem december formal specifications program correctness parallel processing synchronization readers writers problem december
proving parallel programs correct parallel program dijkstra garbage collector proved correct proof method developed degree program makes difficult proof greatly difficulties proving parallel programs correct discussed december garbage collection multiprocessing program correctness multiprocessing tasks
case study code generation technique compilers recent developments optimizing techniques allowed design compilers compiler source code lower level code sequence steps step higher level statements blocks lower level code result statement expansion task code advantage special cases paper evidence strategy result good object code difficult pl statement investigated detailed set simple identified compiler produce good code improve object code contexts statement code produced compiler expansion optimization strategy compares code produced conventional pl optimizing compiler december compiler structure optimizing compiler code generation pl compiler program optimization optimization techniques data flow analysis
conceptual framework nonprocedural programming language sequential programming language programmer explicitly order operations program executed order relevant solution problem requirement sequencing language facilities task nonprocedural manner general program concurrent evaluation paper describes conceptual framework high level programming language providing nonprocedural sequential facilities program nonprocedural sequential program modules nested december parallel programming descriptive programming nonprocedural programming language data flow programming programming
survey science small colleges recent development science student topics science usual programming courses small colleges paper results survey determine type science programs offered colleges results half colleges science program programming courses december science education curricula small colleges december
theorems aid solving file allocation problem file allocation problem problem finding optimal set network file general polynomial complete heuristics aids finding optimal optimal solutions needed paper present theorems applied included optimal allocation november file allocation networks distributed data management december
encoding method sorting indexing sequences character strings order relation sequences considered encoding scheme produces single order string sequence strings original sequence string sequence strings encoding encoding strings variable length maximum length restriction symbols control purposes symbol occur string scheme sorting indexing applications ordering field important november sorting lexicographic order searching encoding december
dynamic memory allocation simulation paper performance dynamic memory allocation algorithms service simulation programs represented test cases performance measured terms processing time memory usage external memory fragmentation algorithms main separate free space lists size memory block perform compared algorithms simple algorithms operating memory ordered lists free list performed algorithms employing power block sizes processing requirements generally memory usage algorithms employing memory ordered free lists generally performed compared november performance dynamic memory allocation dynamic memory management dynamic storage allocation garbage collection list processing memory allocation memory management programming techniques simulation simulation memory management simulation techniques space allocation storage allocation december
improving programs introduction recursion technique program transformation called recursion applied algorithms solve pattern matching problems recursion algorithms manipulate stack recursive algorithms stack operations occur algorithms transformation method recursion elimination called produce programs efficient running time shown fast linear pattern matching knuth morris derived steps simple nonlinear stack november program transformation optimization programs recursion elimination pattern matching algorithms computational induction december
reduction operator simple table perform reduction operator strongly connected regions presented extensions including linear function test replacement discussed algorithms fit integrated package local optimization algorithms november compilers optimization compiled code program analysis operator reduction test replacement strongly connected region december
hashing functions single retrieving method static sets hashing retrieval item static table single considered set methods presented building mechanical hashing functions functions elements unique addresses method quotient reduction method shown complete sense set table elements stored hashing function constructed method found distributed sets method give sparse tables method reduction method complete sense give minimal minimal tables kind set techniques applicable directly small sets methods extend results larger sets presented comparison ordinary hashing shows method practical applications november hashing hashing methods hash coding direct addressing address transformations hashing functions hash coding reduction scatter storage december
high level programming language data processing applications application development today recent years high level languages solution problem business definition language language business data processing problems concepts years manual methods results components defining business forms describing business organization writing calculations november high level language nonprocedural language data flow language business application business data processing structured programming modular programming format specification design methodology december
optimal approach recursive programs classical fixed poin approach recursive programs suggests defined fixed poin solution recursive program approach optimal fixed point defined fixed poin amount valuable information embedded program practical implications approach discussed techniques proving properties optimal fixed poin presentation emphasis examples november recursive programs fixed poin ts optimal fixed poin ts proof techniques december
note free permutation enumeration november permutations free generation december
notation syntactic definitions november wirth syntactic description language extended december
equivalence curve detection matching november picture processing pattern recognition curve detection transformation matching december
behavior percent rule dynamic memory allocation paper reports simulation data showing dynamic memory allocation average free block ratio considerably directions percent rule derivation shown previous make assumption frequently basis simulation data derivation behavior results combined effects systematic statistics process additional simulations support hypothesis systematic natural storage requests end free block selected allocation strategy order blocks groups allocation time degree behavior depends extent blocks order allocation processes extent correlation allocation order order approximately coefficient variation memory time distribution simulations show allocation efficiency depends strongly time distribution efficiency distribution coefficient variation increases practical implications briefly discussed november dynamic memory allocation storage fragmentation percent rule fit simulation december
concurrent writing problem sharing data process considered assumed process time data concurrent writing permitted general theorems proved algorithms presented illustrate include solution general problem read obtained result techniques messages processes solutions mechanism data written process read processes november multiprocessing synchronization readers writers problem shared data december
problem generated images edges detail long generated images increasing resolution display understanding effective methods paper observed terms inherent discusses method evaluating presented application hidden surface algorithms discussed implementation shown examples effectiveness november graphics hidden surface removal sampling december
stack depth distribution simulation paging behavior probability distributions needed virtual memory simulation model page fault distributions working set size distributions members derived stack depth distribution simple expressions computation kinds distributions finally examples distributions computed published stack depth distribution november virtual memory paging stack working set page simulation december
considerations future programming language standards activities paper current state programming language standards activities respect exist published proposed standards fortran cobol pl basic proposals made inclusion future standards extension standards include additional items error conditions documentation november programming languages standards formal descriptions fortran cobol pl basic definition language december
fast string searching presented location character string string string search operation characters starting character information starting match end pattern large text property cases characters string number characters average function length random english pattern length characters string finding match implemented average fewer machine instructions executed conclusions empirical evidence theoretical analysis average behavior worst case behavior linear availability array space tables linear size october search computational complexity information retrieval linear time bound pattern matching text editing december
interactive text processing small computers corrigendum october jr december
multiprocessor memory organization memory interference structure shared memory multiprocessor examined attention memory alternative memory organizations compared shown memory organization processor memories address space effective reducing memory memory organization shown suited specialized computation problems advantages terms reliability general purpose computation results memory drawn previous work comparison trace driven simulations conclusions analysis october smith memory multiprocessing trace driven simulation queueing theory shared memory december
programmer machine software development software development assumption made program development function machine run production machine programming environment alternatives considered paper suggested situations separate program development main function specialized purpose called programmer basic sections paper subject outline general concept discuss areas approach prove describe operational concept october configurations networks software development software engineering software main december
game interpretation deadlock problem deadlock problem defined determination information processes resources operating situations realized smooth running process future flowchart defined steps global approach game operating processes concepts graph representation game construct explicitly set states study properties october operating multiprogramming time sharing resource allocation deadlock deadlock flowchart december
regular part grammars parsers paper alternative context free grammars called regular part grammars syntax diagrams grammars production parts nondeterministic finite state machines special case regular expressions grammars describe syntax programming languages grammars class parsers lr parsers includes lr parsers advantages lr parser determine end handle symbols handle left end end found symbols left handle mechanism determining left end required bound length handle october finite state machines automata regular expressions syntax diagrams lr grammars parser construction parsing programming languages language generation formal definition compilers december
level control structure nondeterministic programming basic ideas nondeterministic programming single proper programming style language allowing direct control nondeterministic features proposed nondeterministic formulation search processes level attempt level coordination problem solving choice level feasibility levels discussed structure choice level free contexts computational environments alternative nodes choice poin ts proposed programming style function choice poin desired choice strategy main advantage approach search strategies node tree state computation choice poin time strategy coordinate alternatives examples term lisp extension lisp designed implemented guidelines october nondeterministic programming artificial control structures search strategy planning context tree december
high level data flow analysis low level text high level data flow analysis deals programs essentially source level control flow information implicit parse tree high level flow analysis aspects recent work advanced methods program certification optimization paper simple general method high level data flow analysis free jump statements large graphs compiling large programs updating data flow information program global information solving familiar global flow analysis problems application variable analysis presented graphs involved constructed analyzed programs compiled avoiding costs low level methods compile time october data flow analysis high level language control flow graph structured programming statements december
interactive graphics approach surface representation teractive graphics method developed rapid generation arbitrary dimensional surfaces method synthesis spline theory algorithms teractive means man machine communication software static dynamic graphics display basic technique employed modified method curves represented uniform splines surface sections splines features method algorithms teractive modification spline representation curves process information displayed user complex surfaces created combination number separately generated automatically successfully variety analytical routines structural graphical applications october graphics dimensional surface representation splines finite element input methods december
optimal surface reconstruction scientific technical dimensional solid serial sections aid object structure facilitate automatic manipulation analysis paper presents general solution problem constructing surface set cross surface triangular constructed separately determining optimal surface pair consecutive determining surface reduced problem finding minimum cost cycles directed graph fast finding cycles utilized developed closed form expression term number contour poin ts upper bound number operations required execute illustrated involves construction minimum area surface describing human head included october surface reconstruction contour data serial sections dimensional graphics minimum cost paths continuous displays december
trees variable length records strategy presented trees variable length records records length distributed file wide distribution record lengths exists file strategy results trees fast access times performance strategy application presented compared strategy analyzed september tree index database tree storage structure searching december
upper bounds generation prime numbers integer computational complexity finding modified linked lists yields arithmetic complexity upper bound shown equivalent theoretical lower bound methods techniques involving space time reduces upper bound log bit complexity log log storage requirement log bits september computational complexity prime number generation number theory linked list december
hardware estimation process primary memory requirements hardware extension processor demonstrated primary memory requirements process multics additional hardware required estimate computed consists program register miss rate associative memory page table words primary memory requirement estimate employed experimental version multics control level multiprogramming memory usage resulting parameters display configuration characteristics workload september primary memory requirement virtual memory level multiprogramming associative memory working set resource allocation stack model characteristics december
analysis substitution structured programming language optimization technique substitution analyzed optimization consists procedure modified procedure general problem substitution minimize execution time subject size ts formulated approximate algorithmic solution proposed depends run time statistics program preliminary results structured programming language programs low degree recursion percent procedure calls eliminated increase size compiled code small savings execution time conclusions based results presented september substitution open coding open compilation program optimization compilers structured programming languages run time statistics december
advanced test science report describes advanced test science recently graduate record examination program program general events leading advanced science test discussed content specifications set sample questions included september education science graduate school test development examinations december
logic programming languages logic long questions principle bounds recently precise comparisons efficiency decision methods developments complexity theory applications logic question methods logic significance applied parts theory programming languages obvious syntactic advanced theory complete examples give wide mathematical queries machine process machine process programs descriptions processes definition precise meaning program requires objects computation problem automata portion field finite state algebraic aspects understanding higher level program features involves infinite objects pass levels conceptual ideas final simulation real machine levels made exact find abstractions represent structures experience independent method data types partial information content ordering continuous demonstrated flexibility approach providing definitions proofs implementations showing abstract theory september logic programming languages automata semantics calculus models partial functions approximation function december
complexity computations framework research theory complexity computations diverse problems methods examples practical theoretical significance directions research discussed september complexity computations algebraic complexity problems probabilistic algorithms december
advantage notation parameter communication august notation notation parameters transmission call call reference call compile time errors december
comment computing shortest paths graph august graph network shortest path december
production employment ph science corrigendum august december
efficient data structure simulation event set recently algorithms presented event scheduling routines suitable general purpose discrete event simulation systems performance superior commonly simple linked list algorithms paper event scheduling presented aspects previously published algorithms performance distributions worst case complexity number events set tests conducted estimate average complexity independent august simulation time flow mechanisms event scanning mechanisms lists december
experimental evaluation data type conventions language programs written substantial effect reliability resulting programs paper discusses experiment compares programming reliability language language analysis number errors number runs errors shows environment language increase programming reliability detailed analysis errors made programming solutions small problems shows difficulty manipulating representation data august data types language design redundancy reliable software december
discipline real time programming programming divided major increasing complexity program sequential programming multiprogramming real time programming programming discipline suitable high level language discipline complexity execution time ts reduced practical make real time systems reliable discipline outlined expressed terms language august wirth multiprogramming real time programming process synchronization processor sharing program december
abstraction mechanisms programming language designed support abstractions program construction work programming methodology kinds abstractions control data abstractions programming process abstraction conventional languages procedure subroutine addition procedures linguistic mechanisms support data control abstractions paper abstraction mechanisms means programming examples utility kinds abstractions program construction illustrated shown programs written implement abstractions library permits incremental program development complete type checking performed compile time discussed august programming languages data types data abstractions control abstractions programming methodology separate compilation december
abstraction verification defining iteration generators form programmer great deal control implementation abstract data types paper abstraction techniques extended simple data representation function definition iteration statement important poin interaction data control structure language means loops operate abstract explicit representation specification verification techniques properties generators expressed form proof rules developed results obtained common special cases loops essentially identical constructs languages means showing generator provided august abstraction representation abstract data types assertions control correctness generators iteration statements modular decomposition program specifications programming languages programming methodology proofs correctness types verification december
early experience users primarily discussed implications similar programming languages suggested specific topics structure defining abstractions data structuring facilities equivalence types type type difficulty making treatment records august morris jr programming languages types modules data structures systems programming december
algol based implementation snobol patterns july patterns snobol pattern matching string processing pattern implementation algorithms december
nonprocedural language iteration formal programs written proofs programs carried proofs easy straightforward produce statements program simply axioms proof conventional logical axioms rules inference special functions programming language things order statements assignment statements equations programs iterative programs conventional structured programming language assignment conditional statements loops july program proving formal systems semantics iteration structured programming december
garbage collection overhead compile time paper discusses techniques automatic storage overhead partially compile time paper transaction oriented collection scheme proposed features summarized implementing requires global flow analysis performed source program shown compile time program actions reference counts cells information find actions code executed achieve improved efficiency july garbage collection global flow analysis list processing optimization reference counts storage management december
certification programs secure information flow paper presents certification mechanism secure flow information program properties structure security classes procedure sufficiently simple easily included analysis phase existing compilers semantics presented proved correct important application problem mechanism prove program results input data july denning denning protection security information flow program certification security classes december
alternative event queues synchronization monitors monitor concept proposed hoare event synchronization paper describes primitive conditional implemented efficiently implementation primitive terms operations correctness proof examples presented readers writers problem problem information sharing finite buffer july monitor operating mutual exclusion synchronization conditional critical region structuring concept december
interactive text processing small computers low cost teractive text handling text analysis users ways comparable teractive search retrieval systems additional features implemented pdp time sharing editing functions simple command language function file search string desired strings context extensive experience shows combined simple commands string circular file structure local memory conversational computing produce powerful sum parts july jr information retrieval text editing time sharing search retrieval analysis linguistic analysis command languages december
terminal oriented communication paper describes full duplex communication time shared terminals consists communications directly connected time shared number small remote computers terminals medium speed telephone lines service large number terminals types design presented algorithms solve specific problems local error detection correction telephone lines character output july terminal error correction local communication network december
correctness proof information main distributed network order nodes distributed network node information network nodes scheme needed update information major ts information scheme central information implemented merit network presented explained general implemented network based heuristic routing correctness proof information presented july distributed network correctness proofs networks distributed control network routing problem networks distributed operating store forward packet switching store forward message switching traffic control december
approach scheduling paper presents scheme scheduling algorithms based abstract model scheduling notion priority classes scheduling algorithms defined related existing algorithms criterion implementation efficiency developed results definition time invariant algorithms include commonly implemented time invariant algorithms processing rates derived abstract model framework implementing flexible real operating systems policy driven discussed implementation july scheduling algorithms scheduling models priority operating systems processor sharing implementation efficiency december
dynamic response time networks computing network resource sharing human component technical component fully investigated achieve goal research step user store resources network analytical simulation statistical performance evaluation tools employed feasibility dynamic response time monitor capable providing comparative response time information users process computing applications network computing node research sufficient data diverse network systems studied detail describe response time network time sharing systems depends measure activity load level july response time monitor networks time sharing systems comparative response time network modeling simulation jobs measurement december
functions word parallel logical complement addition instructions june jr boolean functions complement sign propagation december
recursion elimination methods recursion elimination applied recursive procedure procedures general form arise connection tree sorting algorithms method recursion removal involves solutions compared basis running time june recursion elimination optimization programs trees sorting algorithms computational induction december
bounded storage copying cyclic structures presented cyclic list structures bounded workspace linear time previous similar makes assumptions storage allocation operations high level language feature technique structure spanning tree case left left june copying shared cyclic structures december
buddy systems algorithms presented implementing class buddy systems dynamic storage allocation buddy set recurrence relations block sizes provided analyses fragmentation binary buddy buddy weighted buddy comparative simulation results presented external total fragmentation june dynamic storage allocation buddy fragmentation buddy weighted buddy december
ideas data types high level languages number issues notion data type set values set primitive operations values notation elements finite set notation array data type simple notation allowing types parameters parameters resulting problems conversion values type june data types procedures programming languages december
database abstractions abstraction important real world transforms relationship objects higher level object data type called developed criteria abstractions relational defined structured hierarchy relations main update operations defined relations distinct relations normal form shown important database design top methodology database design decisions structure decisions key identification suggested types types support real world abstractions implementation detail incorporated programming languages june smith smith data abstraction relational database data type database design data structure knowledge representation data definition language december
abstract data types development data structures abstract data types significant role development software reliable efficient flexible paper presents discusses application algebraic technique specification abstract data types examples presented top development symbol table block structured language discussion proof correctness paper discussion problems involved constructing algebraic specifications complete june abstract data type correctness proof data type data structure specification software specification december
business programming language business application describe execute applications user application manipulation information dimensional pictures tables business forms reports display terminal application examples information query database language subset programming language june programming language graphics user data flow forms flow data abstraction database query data processing business specification application programming december
data abstraction june taylor december
experimental utility detailed flowcharts programming paper describes previous research flowcharts series controlled experiments test utility detailed flowcharts aid program composition debugging modification statistically significant difference flowchart groups shown question utility detailed program research suggested june mckay flowcharts program composition program debugging modification experimental testing human factors december
production employment ph science statistics presented production employment ph science calendar data include graduate students ph producing areas significant noted comparisons comparable data calendar made june science production ph employment students december
fast computing common previously published algorithms finding common sequences length case running time problem presented running time log total number ordered pairs positions sequences match worst case running time log applications positions sequence match positions sequence running time log expected common efficient algorithms december
approach optimal design storage parameters database organization storage parameter optimization overflow storage december
optimal evaluation boolean expressions online query query boolean expression information retrieval file organization december
choice reference poin ts match file searching improvements search method match file searching previously achieved step involving calculation reference poin paper discusses proper choice reference poin ts previous reference poin shown reference poin ts data results simulations presented show large improvements achieved proper choice location multiple reference poin ts matching file searching match classification december
comparison hardware software associative memories context graphics associative processing line hardware associative memory dimensional line poin ts lines functions laboratory language data structure comparison hardware approach software simulation advantages hardware associative memory areas processing speed storage requirements flexibility major problem areas hardware associative memory technology input output cost effectiveness associative memory associative processor content memory graphics information retrieval data structures software evaluation hardware evaluation parallel processing database management december
comparison tree algorithms algorithms height avl extensions total restructuring building balanced binary search trees compared criteria comparison theoretical aspects path lengths implementation independent machine dependent measures run time detailed analysis code presented level language compiler independent quality resulting trees overhead building analyzed guidelines efficient methods insertion subsequent queries operations avl trees present binary search trees avl trees balanced trees path length analysis algorithms information storage retrieval december
optimal program data locations networks optimization procedure allocation program data files network presented takes account files programs occur real networks convert programs model search procedure file location problem application model networks distributed optimal file location december
specific accuracy simulation output analysis paper property queueing systems analysis simulation output describes sequential estimation method property results obtained statistical accuracy method includes test check assumption sequential procedure paper method state state describes frequently state state reduces making error preliminary simulation run paper variance reduction method due page obtain accuracy considerably fewer job required variance reduction technique applied ratio property sequential simulation rule variance reduction december
teaching programming compatible subset pl language designed teaching programming features language chosen structured problem solving computers make language easy learn eliminate redundant constructs make language easy compile resulting language suitable programming concepts applications including business data processing scientific calculations numeric computation sequence language subsets called subset programming language constructs constructs subsets subset defined implemented subsets programmer education universities community colleges high pl programming language design teaching programming computing december
proof techniques structured programs method describing structuring programs proofs correctness presented method represents program terms levels abstraction level contained nonprocedural specification proofs programs structured levels manual proofs paper method applicable semi automatic automatic proofs preliminary results method applied large programs operating systems april hierarchical structure program verification structured programming formal specification abstraction programming methodology december
sorting connected parallel algorithms presented sorting elements connected processor array require routing comparison steps previous takes time log algorithms paper shown optimal time small constant factors extensions higher dimensional arrays april parallel parallel sorting parallel merge routing comparison steps processor pattern december
comment weighted linear search scatter tables april hash address primary clustering index sequence relation search december
uniform insertion structured data structures april data structures directed graphs uniform insertion december
approximating block accesses database organizations april database inverted file organization database performance measurement information retrieval query answering december
stage hypothesis curve evidence paper presents results study testing curve stage model development organization research data processing support curve basis stage model results concept stage model analysis suggests alternative model growth models growth growth development resource april jr stage stage hypothesis december
analysis design alternatives virtual memory class index structures virtual memory environment design alternatives class index structures analyzed alternatives include choice search strategy pages index structured keys compressed average cost retrieving entries expressed sum cost basic key comparison cost page boundary index structure formulas retrieval costs combinations design alternatives numerical case studies compare retrieval costs alternatives comparisons main costs insertion deletion reorganization design alternatives included april smith index index structure pages virtual memory files retrieval main search strategy key compression december
studies machine game progress report presented research human decision making human problem solving learning processes hand machine learning large scale programming systems programming techniques make inductive form heuristic rules machines similar results vehicle game conceptual framework provided wide range applicability models human choice decision making incorporated large scale complex program represent descriptive behavior teractive game environment recently established usefulness experiments game enables construct machine strategies line question answering mode april machine learning game programs decision making automatic optimizing heuristic rules automatic inductive inference making models game learning december
editing picture local analysis graphs major problem picture processing elimination large number regions result initial segmentation region techniques regions eliminated basis semantic information basis size scheme presented basis local properties region graph scheme based definitions graph properties satisfied region present editing equivalent fast graph operations number examples shown april picture processing pattern recognition segmentation region editing december
induction proof method induction presented alternative commonly inductive method major prove loop correctness directly input output specification invariant relation induction commonly induction rules shown induction viewed specialized form computation induction set sufficient conditions presented input output specification strong induction steps proof induction valid april morris jr program verification proving programs correct induction rule computation induction inductive assertions structural induction proof rule recursive programs iterative programs december
storage requirement precedence parsing precedence parsing storage requirement table december
comparison fit fit fit memory allocation fit fit fit december
cost utilization measure performance method presented evaluating performance terms cost utilization factor measure coefficients extent total cost effectively utilized method includes technique representation performance performance evaluation cost utilization december
effects user attitudes relationship pricing systems services systems user management attitudes based information systems investigated evidence provided relationship general pattern expected hypothesis growth results systems characteristic advanced stage environments high levels positive user attitudes increases training users factors important user effective control based systems development main based systems change change part user change place research methods science applied user environment effects management stage hypothesis control december
operations sparse relations computations relations boolean matrices directed graphs computation precedence relations context free grammar practical faster common compute operator precedence wirth precedence relations steps shown compute linear precedence functions steps shown compute linear precedence functions steps size algorithms general theorem sufficient conditions expression sparse relations operators composition union inverse computed efficiently iii computational complexity sparse relation boolean matrix directed graph wirth precedence relation linear precedence function grammar precedence relation december
representation sided polygons polygonal lines rapid processing representation polygons polygonal lines sets consecutive examined set binary tree hierarchy inclusion fast testing inclusion poin sided polygon speed discussed practical examples shown poin ts intersection polygonal lines essentially binary tree search practical discussed representation fixed methods representing curves regions boundary line representation graphics structures contour representation information processing graphic data retrieval curves line drawing processing poin ts polygons boundary representation information december
memory management response time paper presents computationally methodology including accurately effects finite memory size workload memory requirements queueing network models systems empirical analyses analytic studies based methodology actual teractive reported relations workload variables memory requirement distribution job time performance measures response time memory utilization displayed model proposed applicable analysis teractive systems memories brown memory management performance queueing network models teractive systems december
empirical evaluation features instruction set processor paper presents methods empirical evaluation features instruction set processors features evaluated terms time feature methods based analysis program concept register answer questions registers simultaneously sufficient time time overhead number registers reduced registers paper discusses problem detecting desirable existing instructions problems briefly discussed experimental results presented obtained analyzing programs running architecture program behavior instruction sets code utilization register structures register utilization simultaneous register instruction execution time december
effective information retrieval term accuracy performance information retrieval systems evaluated number ways published evaluation work based measuring retrieval performance average user query formal proofs difficult construct average case present study retrieval evaluation based optimizing performance specific user query concept query term accuracy probability query term documents relevant query relating term accuracy frequency term documents collection give formal proofs effectiveness respect user query number automatic indexing systems successfully experimental situations inverse document frequency construction phrase generation information retrieval automatic indexing content analysis term accuracy frequency phrase transformations december
improving access time random access files clustering key set key address transformation open chaining file keys address division effect sequential properties key set key search sequence reduce effect file loading number maximum needed record combined effects techniques lead improved file performance secondary storage devices shown empirical studies hashing hashing techniques hashing methods hash coding keys key transformation key address transformation direct addressing direct access direct access method random access file addressing file organizations file structures scatter storage search method clustering information retrieval open addressing open chaining size december
binary trees binary trees permutations binary search trees function december
occurrences class linear programming models investigation average queue size class queues formulation linear programming problems cases solve linear programming models ibm package encountered small input data problems cycle fact observed suggest primary occur frequently round errors computations problem sufficiently case minimizing objective function subject set solved linear programming queueing models december
linear incremental digital display circular circular drawn incremental display device ray digital plotter matrix sign testing elementary addition paper describes methodology producing step patterns true graphics drawing step generation generation incremental digital plotting raster display integer arithmetic december
multiprogramming systems corrigendum december
free working set statistics free average working set size free page rate finite sample reference string defined statistics contents working set start recorded string condition statistics provide estimates expected working set sizes page probabilities distance probabilities pairs shown expressions free statistics obtained terms statistics methods computation discussed usefulness depending length sample number distinct references amount main storage performing calculations methods handling long strings distinct page names working set estimation program behavior december
convex finite sets poin ts dimensions convex sets poin ts dimensions determined log operations presented algorithms technique merge procedure convex convex requires log operations time complexity proposed algorithms optimal constant computational complexity convex optimal algorithms set poin ts set poin ts december
empirical study list structure lisp static measurements list structure large lisp programs reported analyzed paper measurements substantial poin poin lists pointers found law word frequencies natural languages poin lists poin location memory space efficient representation list structure discussed lists successive consecutive memory locations greatly observed list structure shown assumptions information content pair programs measured bits bits clark list structure measurement lisp list structure poin compression law list poin december
approach multidimensional data array processing recent work development general purpose based statistical data processing capabilities handling multidimensional arrays data presented attention general problems multidimensional table array processing summary recent developments array processing capabilities world bank identified world bank retrieval array processing array processing table processing statistical analysis data retrieval data processing syntax data structures computing techniques time series cross december
segment sizes algol programs characteristics virtual memory requirements sample algol programs measured distributions presented memory requests times results presented terms contour model simple abstract machine provide empirical evidence aspects construction behavior real programs implications design virtual memory systems presented discussed january virtual memory program behavior segmentation storage allocation algol contour model january
detection combined occurrences paper variables finite range variable values values variables changing time desired occurrences subset variables achieve values finally problem involves detection large number combined occurrences large number values variables efficient solutions problem methods property faster systems sum larger solution error free suitable cases solution slightly conjunction subject possibility errors error analysis method empirical study reported january jr coding hash coding retrieval secondary keys pattern recognition artificial sorting chess january
record file partitioning model main objectives design file reduction storage data transfer costs paper presents model requests access file request requires information variable length data items probabilities access distribution data item length assumed independent file storage devices record stored devices primary record request record made primary record accessed accessed pertinent information stored primary record model presented paper nonlinear programming model mixed integer programming model general types file systems derived selection parameters model optimization library routines storage large scale operating january file file design file partitioning record partitioning january
survey literature science education curriculum approximately references science education literature curriculum presented descriptive organizing references survey reports activities professional organizations philosophy programs description programs description courses january education science curricula january
structured programming cobol approach application programmers techniques designing writing cobol programs presented previous work structured programming drawn presentation terminology theorems proved examples frequently top program design implemented structured flowcharts specifications step step verification formed cobol program defined proper cobol coding discussed january van structured programming top formed program statement statement flowchart application programming cobol software reliability program verification january
implications structured programming machine architecture based empirical study lines program text written language machine architecture specifically designed structured programs proposed assignment call statements account percent statements special statements implemented efficiently highly compact instruction encoding scheme presented reduce program size factor code variable length fields method fixed length code address fields instructions single field instruction time minimized machine efficient respect space time machine architecture architecture organization instruction set design program characteristics
variable partition paging algorithms types behavior occur paged virtual memory operating systems type fact reference strings paging algorithms increase memory allocation result increase fault rate paging algorithms examined terms potential reference string examples presented paging properties inclusion property generalized inclusion property discussed implications properties presented graham memory management program behavior stack algorithms virtual memory working set page fault frequency paging algorithms
complexity computations corrigendum
average arrays programmers data structure designers alternative structures storing structures logical important consideration combinatorial problem storing arrays kinds list structures examined graphs model loss involved storage schemes elementary proof arrays stored linear lists bounded loss presented average loss considered shown arrays stored linear lists bounded loss average stored binary trees result implies row major order optimal storage strategy arrays arrays graph linear lists average trees
sided height balanced trees recently established sided height balanced trees log 2n steps proved performed log 2n steps open problem avl trees balanced trees binary search dynamic
science students technological investigated special attention complexity structures science students technology social science students students university science found complex structure social science values attitudes students public social effects
management utilization computers american local traditional concepts management information systems relation information systems top management local exists management oriented computing involving applications nature systems management computing common extent local management computing professional management top management computing control computing decisions department users control design implementation activities finally management computing top involving improvements decision information utilization management information american local government government computers government computers management computing
interactive information storage retrieval research paper presents results study interactive computerized storage retrieval monitor built provided usage data study additional data user results show important role frequently chosen laboratory reference implications study design similar systems discussed implementation information storage retrieval
methods detecting step edges digital pictures note describes operators step edges similar digital sum differences difference gray levels obtained operators applied set test pictures compared standard digital operator distance center edge briefly considered equivalent standard digital approximations image processing pattern recognition edge detection
assertions proving program correctness paper technique proving correctness termination programs simultaneously approach method involves program assertions true time control point true time method introduced provide valuable complement conventional methods method presented number examples correctness termination proofs proofs simpler conventional hand shown proof correctness termination conventional techniques directly proof assertions finally shown method applied prove program transformations correctness operating programs assertions correctness programs termination programs program verification program transformation operating programs
relaxation methods image reconstruction problem image function variables integrals great importance large number scientific areas important version problem obtaining exact density distribution human ray approach solve problem consists information linear size resulting fewer percent coefficients makes methods successive computationally compared ways solving systems paper shown linear sequence parameters generates sequence vectors solution assumptions linear equations relaxation method minimum solution previously proposed techniques shown special cases procedure relaxation parameters practical image reconstruction choice relaxation parameters discussed image processing image reconstruction ray mathematical programming linear relaxation techniques
comparison numerical techniques markov modeling paper presents numerical methods obtain probability vectors models considered results obtained methods examined standard techniques yield correct results finally means estimating error inherent decomposition models presented markov models numerical techniques simultaneous iteration
trees examined tree increasing frequency proposed basic storage structure database applications potential problems structure arise traditional static directory structures problem performance tree directory static directory dynamic directory index sequential access method
edges regard conflicts intersection graphs presented method determining conflicts heuristic combinatorial optimization problem connection method optimization problem shown equivalent problem edges graph complete objective minimizing number complete relationship edge cover problem graph problem established algorithms problems constructed relationship conflict problem edge cover problem shown complete polynomial time approximation algorithms produce solutions factor optimum conflicts intersection graphs node cover edge cover computational complexity complete problems polynomial time heuristics
advanced test science
systematic recursion removal recursion removal presented strong applied complex pl program demonstrate systematic recursion removal techniques complex knuth obtain measurements cost procedure linkage pl savings procedure integration recursion paper describes recursion removal process illustrated recursion removal applied major parts final result process displayed performance comparison results presented conclusions briefly discussed strong recursion removal recursion elimination optimization procedure linkage procedure integration
method obtaining digital public key encryption method presented property encryption key key important secure means needed keys message encryption key intended message key message key encryption key obvious applications electronic electronic transfer systems message representing number power result divided product large prime numbers similar power security part difficulty published divisor digital public key privacy authentication security factorization prime number electronic message electronic transfer
science current status women results survey conducted determine status women members academic science presented members compared respect professional background teaching load records research analysis data general women women science degree programs action teaching
architecture ibm paper discusses design considerations extensions comments original objectives achieve describes reasons objectives architecture virtual storage program control data manipulation instructions timing facilities multiprocessing debugging monitoring error handling input output operations final section important parameters ibm machines implement architecture january case systems architecture instruction sets virtual storage error handling
paper describes discusses evolution architecture account problems built date class requirement capable processing floating point operations fortran compiler designed give scientific user access vector processing architecture optimizing compiler loops compatible fortran standard commonly fortran extensions require source program modifications additional fortran statements achieve user man effort develop fortran programs computers january architecture systems
evolution pdp pdp implementations include systems price range evolution hardware operating languages terms technological change user requirements user developments pdp computing technology include transition batch oriented time sharing computing systems hardware technology design hardware software development model single user interactive systems january bell hill structures architecture operating
evolution univac series analysis projection series systems univac large scale main frame systems series compatible models introduced series hardware architecture based bit word complement structure storage high speed register high speed registers operating designed support multiprocessor configuration simultaneously providing multiprogrammed batch transaction environments january series architecture multiprocessing languages data management systems end user facilities executive control software
development outline background project ideas discussed description instruction set includes number features production efficient compiled code high level language source programs design processor initial ideas store final structure involving mechanism instruction function queue array element view complete complex presented performance january architecture virtual storage instruction set instruction associative storage function queue complex
mark perspective years design university systems mark developed period paper context describes architecture software present day terminology design concepts address generation store management mark impact areas discussed performance mark evaluated january architecture index registers paging virtual storage codes compilers operating systems mark
special architecture january
hierarchical design proof hierarchical programming construction large programs users hierarchical techniques substantial increases reliability programs produced paper describe formal method hierarchical program specification implementation proof method significant list processing problem discuss number extensions current programming languages ease hierarchical program design proof december program verification specification data abstraction software modules hierarchical structures dh january
abstract data types software data abstraction algebraic axioms axioms permit representation independent formal specification data type shows algebraic axioms successive levels implementation major paper shown algebraic simplify process proving correctness implementation abstract data type semi automatic tools proofs correctness derive implementation axioms implementation limited testing programs design time conventional implementation accomplished december abstract data type correctness proof data type data structure specification dh january
reverse path packet nodes network algorithms store forward packet switching network include transmission separately addressing spanning tree source based list algorithms reverse path routing method routing procedures data structures packet switching reverse path practical routing store forward packet switching networks practical optimal developed analysis paper implemented existing networks complexity required alternatives december reverse path routing networks store forward packet switching dh january
optimizing decision trees search optimal decision table conversion literature approaches dynamic programming bound technique effective time space requirements independent easy table produce good optimal solutions bound technique good heuristic direct search search space number solutions increases number test variables double exponential paper suggest top search dynamic programming identical find optimal optimal solutions heuristic search method introduced paper positive aspects techniques compressed tables large number variables handled tables december decision table optimal decision table conversion decision tree heuristic search graphs dynamic programming bound dh january
detection logical errors decision table programs paper logical errors limited entry decision table loop free programs embedded decision tables developed conditions decision tables assumed relating linear expressions assumed actions decision table linear variables occur condition decision table tables control table based determining set linear solution paper implemented fortran iv december error decision tables dh january
planning methodology computing effort higher education empirical evaluation study designed address problems planning computing effort higher education presented planning methodology developed tested implementation university years methodology implemented effectiveness planning methodology terms improvement computing services major instruction research administration control institutions employed improvements test results research planning methodology significantly computing services december management university computing planning dh january
selection optimal generation terminals selected set feature reduce number characters needed represent document transmission note selecting optimal set minimizing number characters implementation reduced number characters percent requires document compute matrix determining optimal set fixed heuristic alternative achieve percent optimal december word processing dynamic programming dh january
linear finding prime numbers presented finding time proportional multiplication integers larger performed unit time method arithmetic complexity presented version simpler easily extended find prime factorization integers time proportional december algorithms data structures dh january
encryption authentication large networks computers encryption achieve communication networks discussed presented management verification document conventional public key encryption algorithms considered basis december encryption security authentication networks public key data encryption standard dh january
garbage collection sequential processes mutual interference large shared data space technique developed activity needed garbage detection collection performed additional processor operating processor computation proper exclusion synchronization constraints achieved illustrated november dijkstra multiprocessing sequential processes minimized mutual exclusion program correctness multiprogramming tasks garbage collection dh january
expressions network representation presented combinatorial search problem finding values set variables subject set constraints theory consistency levels networks formulated related problems tree search efficiency developed achieve level consistency desired order problem subsequent search function alternative search explicitly determining solutions november combinatorial algorithms networks graph network consistency relaxation search dh january
trees fast technique frequently keys trees technique searching sets keys highly frequency distributions tree binary search tree node key values node key partitions keys respect lexical ordering left tree lexical node search tree balanced space efficient representation tree high search speed frequency ordered binary search trees cost successful search log bounded stable minimal values built key ordering set frequencies time log optimum binary search tree discussion application dictionary english presented performance obtained techniques november tree search dictionary binary search balanced trees law information retrieval dh january
power trees class trees presented height nodes paths number nodes tree power height worst case procedure node insertion class trees considered restricted trees procedure average behavior trees studied extensive set simulation runs avl trees family trees main advantage reduced number required node insertion analyzed november binary search trees trees trees search length node insertion dh january
distributed processes concurrent programming concept language concept concurrent processes common variables introduced processes means procedure calls regions concept proposed real time applications controlled networks distributed storage paper examples distributed processes shows include procedures coroutines classes monitors processes semaphores path expressions input output special cases november concurrent programming distributed processes networks regions programming languages process communication scheduling sorting arrays coroutines classes monitors processes semaphores path expressions input output dh january
note conditional expressions evaluation conditional expression alternatives records nodes fields content november parallel evaluation lisp conditional forms function infinite structures dh january
simple recovery procedure simple precedence parsers simple method simple precedence parsers syntax errors attempt errors made parsing semantic processing result good approximation syntax error handling increase parsing time space complexity parser table generator november syntax errors error recovery parsing simple precedence compilers debugging dh january
generation gamma random variables ii method proposed generating gamma shape parameter method similar methods faster methods core storage requirements programming effort proposed method similar methods computational times proposed method constant medium large values superior times obtained method values proposed method simpler method november gamma variables method methods dh january
synthetic images register real images surface models number image analysis tasks image model surface automatic visible light images requires exact images digital models addition automatic classification requires deal correctly effects angle surface techniques parts improved means achieve required matching real image synthetic image obtained surface model positions light synthetic image calculated map convenient describing surface function surface illustrate technique images digital models november image synthetic images surface models automatic hill digital models image transformation image matching images dh january
performance evaluation highly concurrent computers deterministic simulation simulation presented practical technique performance evaluation alternative configurations highly concurrent computers technique constructing detailed deterministic simulation model model control instruction data real simulation model yields timing resource usage statistics needed performance evaluation case study implementation model cpu memory ibm results evaluating alternative designs discussed experiments case study major memory unit fixed point unit appears sophisticated technique architecture ibm high speed memory ibm november performance evaluation deterministic simulation control concurrent computers dh january
simply extended modified batch environment graphical complete batch environment graphical components handling graphical data files contents files variety graphical hardware performing graphical batch input operations easy extend large batch environment fully interactive paper presents conceptual view graphics leading design major components design basic assumption true graphics describe graphical commonly provide graphical input output functional capabilities built basic graphical data management common means communicating descriptions graphical components facilities storing retrieving manipulating descriptions graphical provided received application programs graphics packages graphical devices november graphics data structures graphic display graphic input graphical database device independent graphics dh january
systems design education approach problems problem made mix jobs center service paper presents management game job mix control game variety real world situations bound jobs compute bound jobs game set detailed reports cost simulated run center operating november design configuration management game dh january
comparison structure simulation event set october simulation event set structure dh january
start start miss level storage hierarchy miss ratio measurements made start made level store large effect measured miss ratio level store significant long reference strings start start miss observed shape miss ratio capacity curve property behavior programs constant number pages main storage hand start miss measured function capacity measurement length systems operation program task shown obtain simple assumptions miss ratio multiprogramming start miss ratio values obtain approximate start miss start miss october miss ratio start start storage hierarchy function multiprogramming shape dh january
scatter tables scatter tables open addressing recursive entry auxiliary cost functions compared conventional methods techniques provide substantially improved tables exact solution optimal depth limited approximations optimization costs linear table size techniques primarily suited important fixed possibly large tables reference frequencies code tables spelling access arrays introduction frequency october assignment problem programming hashing open addressing recursion scatter table dh january
implementing quicksort programs paper practical study implement quicksort sorting real computers including code optimization techniques detailed implementation combining effective improvements quicksort discussion implement assembly language analytic results describing performance programs summarized variety special situations considered practical illustrate quicksort wide applicability internal sorting method requires storage october quicksort analysis algorithms code optimization sorting dh january
analysis algorithms national problem solutions national problem dijkstra dijkstra simple program improved program algorithms dijkstra shown expected number values shown expected complexity october algorithmic analysis national problem structured programming dh january
counting large numbers events small registers small approximate counts large numbers resulting expected error controlled bit events relative error substantially independent number events relative error expected percent percent time techniques advantage counting hardware software monitoring experiments processes october morris counting dh january
optimal matching gray level transformation paper problem optimal matching gray level transformation picture points gray level gray level objective find digital picture picture sum errors gray level picture reference picture minimized equivalent ordered objects ordered sizes error space minimized function polynomial time solution problem tree search optimal matching presented time complexity property problem complete restricted october optimal matching gray level transformation problem tree searching picture processing dh january
jump searching fast sequential search technique sequential file structures binary searching feasible jump searching alternative paper jump searching scheme optimum jump size square root number records multiple level variable size jump strategies applications discussed performance evaluated october jump searching sequential files file management search strategies database structures index searching dh january
models parallel processing programs application cpu overlap approximate queueing models internal parallel processing individual programs multiprogrammed developed paper solution technique developed network decomposition models formulated terms cpu overlap applied analysis problems performance improvement cpu overlap found greatest systems approximate cpu utilization low multiprogramming improvement overlap found greatest utilized cpu october multiprogramming parallel processing queueing network models multiprocessing computation dh january
fortran standard fortran american national standard programming language fortran x3 commonly fortran development fortran standard x3 paper describes features fortran information standard developed october dh january
simulations dynamic sequential search algorithms september searching list processing sequential searching dynamic simulation dh january
real time plotting approximate contour maps september contour map digital plotting graphical characters dh january
note virtual memory september index tree pages file organization linked representation maintenance costs dh january
event manipulation discrete simulations requiring large numbers events event manipulation presented consists major parts part addresses familiar problem event scheduling efficiency number events large part deals problem providing efficiency flexibility events accessed executed additional features problems include proper handling simultaneous events events created executed points simulated time infinite loops caused time events maintaining event counts practical capability handling time events desirable september simulation discrete systems simulation discrete event simulation time flow mechanisms dh january
trees insertion deletion provided class sided trees log performance importance results relationship trees insertion operating log2 insertion deletion carried log time trees appears insertion difficult deletion reverse september dictionary problem search trees avl trees trees balanced trees sided height balanced trees insertion deletion algorithms dh january
controlled experiment program testing code paper describes experiment program testing employing highly data processing methods test small pl program results show code method effective based methods finding errors effective methods terms errors found cost employed pairs tested program independently study shows amount ability types errors method method september software reliability program verification debugging testing code code selection dh
generalized working sets segment reference strings working set concept extended programs reference segments sizes generalized working set policy set segments costs retrieval costs model entire class demand memory policies satisfy set inclusion property generalized optimal policy defined operating points minimizes costs special cases cost structure stack working set efficient procedures computing demand curves showing load function memory usage developed policies empirical data actual included september denning database memory management optimal memory policies paging program behavior program measurement segmentation working sets dh
model verification data security operating systems program verification applied forms method providing secure shared systems precise definition data security developed terms general model operating systems model suitable basis properties operating reliable security application approach secure operating discussed september operating systems security protection program verification dh
practical data flow analysis data flow analysis presented analyzed procedure program information variables modified possibly call procedure sufficiently powerful recursive programs deal sharing variables reference parameters unique compute information single pass requiring compute relationships sharing patterns optimal time complexity implemented practical programs large september data flow analysis global flow analysis optimization side effects relations reference parameters dh
simulation models systems paper describes structure operation simulation model discrete event simulation analytic techniques combined produce efficient accurate models based simple discrete event simulation model jobs central queueing network models processors accuracy efficiency technique demonstrated comparing result computational costs model equivalent simulation model september performance evaluation simulation queueing network models central model dh
symbolic techniques classification fields note presented symbolic calculation algebraic tensor permits determination types field specialized clark requires special coordinate coefficient formalism implemented formac designed complete classification scheme proposed examples september general types formac symbolic manipulation dh
feedback resource allocation policies multiprogramming multiprocessor model studies integrated feedback driven scheduling systems multiprogrammed multiprocessor systems presented basic control variables data flow rates processes executing cpu model systems feature simulated continuous flow scheduling input output activity attention amount memory resource required effective processing activity buffer space assignment model studies distribution driven trace driven techniques simple dynamic shown improve performance measured user cpu time optimal optimal static identical structures workload environments improvement greatest demand workload august integrated feedback scheduling multiprogramming systems scheduling dh
communicating sequential processes paper suggests input output basic primitives programming parallel composition communicating sequential processes fundamental program structuring method combined development dijkstra command concepts illustrated sample solutions variety familiar programming august hoare programming programming languages programming primitives program structures parallel programming input output commands coroutines procedures multiple entries multiple classes data representations recursion conditional critical regions monitors iterative arrays dh
time space efficient garbage area storage nodes sizes compact end area pointers nodes show locations task linear time relative size storage area space order bit operates encoding situation collection locations point single location linear list pointed location locations pointed location contents august morris garbage collection compact storage storage allocation record structures list processing free storage pointers data structures dh
fast parallel sorting algorithms parallel sort presented requires time log processors makes technique requires space product processors time model model memory permitted procedure presented sort numbers time log processors arbitrary integer model computation procedure permits simultaneous memory location august parallel processing sorting algorithms sort dh
conflicts social choice electronic transfer developments years based systems transfer implemented large scale systems institutions potential significant social legal technical questions full scale systems electronic transfer eft problems larger public solve paper examines eft developments social problems context conflicts positions implicit analyses proposed eft conflicts relative importance problems specific groups positions implicit eft proposals analyses reliability privacy topics analyzed article related positions concerned ways public learn social eft eft developments discussed context social choice august electronic transfer systems social computing privacy social choice networks network reliability security social values dh
programming style functional style algebra programs conventional programming languages inherent basic level primitive word time style programming common semantics state division programming world expressions world statements effectively powerful combining forms building programs existing lack mathematical properties programs alternative functional style programming combining forms programs functional programs deal structured data nonrecursive constructed arguments require complex procedure declarations generally applicable combining forms high level programs higher level style conventional languages functional style programming algebra programs variables range programs operations combining forms algebra transform programs solve equations programs transforms equations high school algebra transformations algebraic carried language programs written combining forms chosen programming power power algebraic general theorems algebra give detailed behavior termination conditions large classes programs class computing systems functional programming style programming language state transition rules languages systems semantics states state transition occurs major computation august functional programming algebra programs combining forms functional forms programming languages computers languages models computing systems computing systems state transition systems program transformation program correctness program termination dh
analysis availability systems aided algebra analytical results related availability constructed processors presented paper results obtained aided algebraic manipulation techniques major purpose paper demonstrate difficulties obtaining analytical solutions markov processes considerably reduced application symbol manipulation programs physical systems markov semi markov processes potential range application techniques problem availability analyzed july aided algebra symbol manipulation markov process reliability redundant structures line dh
simple technique fast complete formulas function symbols presented proof correctness july theorem proving program verification dh
proving correctness code proving programs written high level language correctly low level language primary optimization step code generation low level language programs generated compiler fact hand coded examples usefulness interesting results ability handle programs implement recursion start program detection wide class errors low level language programs examples demonstrate optimization paper result substantially faster operation memory terms program stack sizes july compilers correctness code optimization debugging program verification lisp dh
binding lisp binding scheme variable accessed bounded amount computation model binding lisp presented context switching environment tree transformation called completely general sense lisp interpreter operate correctly context change invariant variables environments programmer access primitive dynamic control accesses speed execution program semantics addition multiple processes active environment structure long operation finally concept shown concept binding lisp dijkstra display algol general model binding july jr lisp environment trees binding binding multiprogramming algol display dh
time ordering events distributed concept event distributed examined shown define partial ordering events distributed logical order events total ordering illustrated method solving synchronization problems specialized physical bound derived july distributed systems networks synchronization systems dh
hash tables paper presents resolution method half open addressing chaining fact link fields present cell hash table permits chaining overflow items table efficiency method derived analysis july hash code scatter storage open addressing chaining resolution searching uniform dh
interpolation search log search interpolation search method retrieving desired record key ordered file key statistical distribution keys shown average log file accesses required key keys distributed number accesses shown low distribution function keys computational experiments results july average number accesses binary search database interpolation search retrieval searching uniform distribution dh
determining optimal computation order matrix chain products paper discusses computation matrix chain products form m1 matrices order matrices computed number operations sufficient condition matrices optimal order presented find order computation takes percent longer optimal time presented cases yields optimal order order takes percent longer percent average july approximate heuristic matrix multiplication matrix chain product dh
complexity computing measure decision tree complexity computing measure union possibly intervals shown log comparisons linear functions interval allowed existence log lower bound determine real numbers demonstrated problems provide effects computational model ease analysis results produced july analysis algorithms combinatorial problems computational complexity computational models decision tree programs lower bounds dh
english language question answering large relational database requests english users obtain explicit large relational database maintenance data called design implementation illustrated detailed examples operation components examples operation language processing portion number transition networks specific meaning context registers concept case questions generating partially questions reference problems components construct formal query relational database order searching relations methods discussed handling complex questions providing ability included important issues programming natural language systems limited domains relationship july question answering relational database natural language database end artificial intelligence query generation information retrieval natural language programming dh
general equations cpu overlap configurations general equations derived estimating maximum utilization main storage partitions cpu devices conditions cpu overlap model multiprogrammed systems equations directly applicable configuration sets identical cpu processors main storage partitions user tasks examples provided illustrate equations compute effective processing time record expected response time balanced resource utilization conditions june input output overlap performance resource allocation dh
performance recovery systems mathematical model transaction oriented proposed assumed operate recovery method reliable information processing model derive principal performance measures including availability response time point june database reliability file systems recovery procedures checking techniques reliability performance evaluation dh
automated service integration political economy computing automated operations reported major impact increase internal efficiency impact product technical features based successful automated information systems fit political groups june social computing computing management information systems computing information systems service integration information systems dh
basic programming research relationship processing characteristics programs experience characteristics programmers program development time objective develop technique amount time create program program characteristics increase programming time required specifications programmer characteristics experience related programming task program characteristics major program development time increased program development time programmer characteristics found related reduced program development time multiple regression equation contained programmer characteristic program characteristics evidence good power program development time june programmer performance standards program development time program estimation techniques program development equation programming experience programmer evaluation programmer scheduling programmer programming management cobol programming dh
characteristics application software maintenance maintenance application software major portion total cycle cost estimates total systems programming resources range high percent area attention literature problems area developed organizations analyzed statistical package results analysis maintenance total resources systems programming groups maintenance viewed management important application software development maintenance problems management significant technical user extension important management problem area june software maintenance aids management technical issues dh
automatic error recovery lr parsers paper present scheme detecting syntax errors programs scheme based lr parsing driven information directly automatically information present lr parser approach graham appears provide error recovery simple powerful june programming languages error correction automatic correction parsing lr syntax errors compilers dh
analyses deterministic parsing algorithms paper describes approach determining minimum maximum average times parse sentences deterministic parser quantities presented form symbolic formulas called time formulas variables formulas represent length input string time perform elementary operations binding variables actual numerical values compiler machine configuration determine execution time configuration time formulas derived grammar rules program representing approach specific grammar simple arithmetic expressions deterministic parsers analyzed top recursive parser bottom parser paper estimates relative parsers estimates applicable specific machine pdp presented finally paper proposed approach analyses parsers simple programming language june syntactic analysis analysis algorithms top bottom parsing relative dh
selective binary search trees problem selecting data items binary search tree list range conditions considered process minimal number nodes data range conditions called selective presented paper selective field node tree efficient examination data time examination field june data retrieval range conditions binary search tree tree selective dh
optimal method deletion sided height balanced trees sided height balanced tree binary tree node height equal greater height left advantage general avl tree bit information required bits required tree shown deletion arbitrary node tree accomplished operations number nodes tree method optimal sense complexity reduced order result earlier results basic problems insertion deletion retrieval insertion modification avl tree june balanced binary search trees dh
optimal shift strategy block transfer memory purposes paper block transfer memory serial shift registers shift rate definite minimum shift rate rate definite maximum shift rate bits shift registers blocks bits starting bit shift strategy block transfer request random time minimal amount time bit minimum shift rate requirement simply bit transfer request optimal strategy involves bit critical boundary bit called strategy field block transfer memory viewed paging drum variable bounded speed paging drum devices shift register memory memory hierarchy electronic drum latency dh
generation gamma random variables method generating random variables gamma distribution shape parameter proposed method similar methods recently compared methods core storage requirements programming effort method similar method proposed method method faster method proposed method simpler method faster gamma variables method methods dh
sufficient conditions integer programming application purpose report present class sufficient conditions mixed integer programming problems sets sufficient conditions presented conditions based primal dual linear programming sufficient conditions construction difficult integer programming problems optimal solutions problems test integer programming codes integer programming conditions test problem construction conditions greatest common divisor dh
interference matching technique abstractions method knowledge abstraction sequence training examples proposed method interference matching abstractions finding relational properties common tasks solved program interference matching presented problems description training examples interference matching discussed directions future research considered rule induction knowledge partial matching interference graph matching learning induction knowledge representation retrieval abstraction generalization language learning complexity dh
procedure mechanism paper describes integrated procedure mechanism permits procedures recursive functions coroutines integration accomplished procedures records called environments data objects procedure separate components source language level addition argument binding control programmer definition methods argument transmission source language resulting procedure mechanism part programming language suited goal oriented problems problems readily programmed coroutines examples procedures coroutines programming languages interpreters snobol dh
units programming languages issues programming language aid physical units discussed method introduction relationships units subsequent automatic conversion based relationships proposals syntax considered iii units language design compiler construction language syntax dh
automatic data structure selection levels abstraction proved constructing maintaining programs programs designed abstract data types sets lists programmer time process low level implementation details past programming systems provided single general purpose implementation abstract type programs produced abstract types space time paper automatically efficient implementations abstract types library implementations discussed process discussed detail program general issues data structure selection reviewed low abstract data types automatic programming data structures optimizing compilers sets lists dh
test data aid proving program correctness proofs program correctness long testing detecting errors correctness paper techniques test data proving program correctness addition process proving correctness method process providing accurate specification program applicability technique procedures recursive programs demonstrated program verification program testing recursive programs dh
language extension constraints data access controlled sharing information needed desirable applications operating systems access control mechanisms paper shows extend programming languages provide controlled sharing extension permits expression access constraints shared data access constraints simple objects objects components larger objects bank account records bank data base constraints stated static checking similar type checking approach extend strongly language suitable languages support notion abstract data types programming languages access control data types abstract data types type checking capabilities dh
fast copying list structures presented copying linked list structure block storage locations original list fixed number program variables auxiliary storage stack mark bits operates linear time shown significantly faster fisher previous linear time problem speed efficient list technique processing stack structure built classification list cells types enables processing operations type clark list copying lisp space complexity constant workspace dh
generating shape parameters method generating method compared previously published methods suggested method advantages speed programming simplicity previous methods difficult combinations parameter values april random numbers simulation dh
encoding strings method insertion strings symbols presented lengths strings increase cost terms small compared lengths strings april string transmission encoding integers dh
data structure manipulating priority queues data structure representing collection priority queues primitive operations insertion deletion union update search item priority april data structures implementation set operations priority queues binary trees dh
code machines dependent instructions computers instructions lengths distance instruction instruction paper considers problem minimizing lengths programs machines efficient solution presented case dependent instruction assembly time expression restricted restriction allowing general assembly time expressions problem shown complete april dependent instructions variable length addressing code generation compilers complete computational complexity dh
secure communications traditional security key means messages paper shows key open communications communications security method amount work increases square work required key method kind protection suggests research highly theoretical practical sense april security communications security network security key distribution public key dh
list processing real time serial real time list processing time required elementary list operations lisp bounded small constant classical implementations list processing systems lack property list cell garbage collection process requires time proportional size real time list processing presented garbage including directed cycles cells locations avoid free storage program small requires time sharing making suitable finally requires average time space classical implementation space requirements reduced approximately classical compact list representation arrays sizes program stack hash linking simple extensions reference counting found applications april real time garbage collection list processing virtual memory file database management storage management storage allocation lisp coding reference counting dh
optimal conversion extended entry decision tables general cost criteria general dynamic programming converting limited extended mixed entry decision tables optimal decision trees presented account rule frequencies probabilities minimum time space cost criteria common action sets compressed rules rules sequencing constraints condition tests combinations conditions ambiguities rule april decision table optimal programs dynamic programming dh
technique differences files simple differences files application comparing source program file order display differences differences notion difference easy implement computationally efficient time linear file length applications differences similar common application files independently generated single file generate efficient file form differences file reconstruction original file difference files april difference word processing text editing program maintenance hash coding file compression compression common file comparison evolution dh
enumeration binary matrices applied text encryption binary matrices order field initial segment natural numbers correspondence natural number intermediate vectors vectors binary matrix examples complete enumeration binary matrices produced mapping intermediate vectors matrices mapping application encipherment method pseudorandom number sequences bit string formed form text data encryption key representation natural number natural number binary matrix key obtained matrix shift register sequence pseudorandom number generator april binary matrices combinations matrices encryption pseudorandom numbers feedback sequences random numbers dh
interference detection surfaces environments determine interference components potential interference problems products made components product testing attempt dimensional static medium show dimensional moving parts paper presents representation surfaces algorithms interference checking objects represented objects represented surfaces types interference checking discussed detection objects fixed positions detection objects moving january interference checking intersection detection detection solid representation representation graphics polygons surfaces dh april
impact technology past significant growth technology growth rate early applications extend routine resource allocation aided systems machine tool decision making planning machine interaction results technology date mixed paper reports case studies implementation impact technology relationship technology law society january technology resource allocation command control aided law technology transfer dh april
permutation data blocks memory common internal organization memories consists set loops connected major loop problem obtaining give permutation loop contents minimum time studied paper lower bound number steps required permutation derived class optimum algorithms identified january memory memory loops permutation data block shift dh april
impact distributions multiple processor systems simple queueing models study performance multiple processor systems issues considered include impact cpu service distributions level multiprogramming job january multiprogramming multiprocessing scheduling performance evaluation queueing models dh april
event driven compiling technique due linear structure source text difficulties arise pass compilation process difficulties occur processed forward reference information subsequent solutions data structures case technique presented control structures events processes work compiler practice problems special processing problem technique applied construction algol compiler examples implementation discussed january compiling technique pass compilation semantic analysis event process parallelism dh april
syntactic source source transforms program manipulation syntactic transforms source source program transformations history computation execution time combined small number primitive semantic transforms provide powerful tool program manipulation syntactic transforms solution program equations examples derivation complex source source transformations presented case studies illustrate syntactic semantic source source transformations development simple efficient programs january structured programming program transforms control structures dh april
production employment ph science science production ph employment students dh april
employment characteristics level employment characteristics utilization dh april
recursive data structures mathematical study approaches defining nested arrays presented theorems relationships systems illustrated graph representations approaches define array recursive data structure equivalent tree structure data stored arrays numbers characters extension proposed includes primitive functions manipulate level arrays operators assist construction data driven algorithms nested arrays arrays recursive data structures trees data driven algorithms theory arrays dh april
global optimization partial elimination redundant computations moving invariant computations loops separately loop loop move expression directly loop invariant solving general problem elimination computations performed execution path computations partially redundant require graphical information restrictions shape program graph testing shown execution cost linear size program smaller requires execution time optimization compiler compilation redundancy elimination invariant computation elimination partial redundancy data flow analysis boolean systems dh april
comments hashing functions single retrieving method static sets hashing hashing methods hash coding direct addressing address transformations hashing functions hash coding reduction retrieving scatter storage searching dh april
real time operating real time operating designed large set machines running application programs written high level language implemented software hardware interface user programs application programs highly structuring programs networks communicating processes providing efficient communication primitives real time operating systems dh april
synchronization synchronization concurrent processes requires relative ordering events processes synchronization mechanism proposed abstract objects called processes control ordering events directly mutual exclusion shared variables control ordering events direct control ordering simplify correctness arguments implementation distributed systems mechanism defined examples relationship mechanism protection mechanisms explained shown applicable situations information implementation shared memory process synchronization communication distributed systems security models mutual exclusion semaphores dh april
optimal storage allocation serial files serial files files direct access storage device storage space limited records added files jobs batch processing mode line transaction job generates demand vector space required file record addition file runs space paper considers criteria storage space files serial files storage allocation reorganization dh april
curriculum recommendations undergraduate program science contained report recommendations undergraduate degree program science curriculum committee science computing acm core curriculum common science undergraduate programs presented terms elementary level topics courses intermediate level courses courses round undergraduate program discussed entire program including science component material presented issues related undergraduate science education service courses areas education facilities presented sciences courses science curriculum science education science undergraduate degree programs service courses education dh april
focus number focus number computational algorithms control signal processing applications focus wide character floating point numbers state distributions give focus accuracy advantage equal word length floating point focus computations times faster single precision fixed point integer arithmetic operations comparable speed hardware arithmetic applications algorithms bit bit implementations focus included number representation logarithmic arithmetic computational speed computational accuracy applications dh april
experiments algorithms find central solutions pattern classification class pattern recognition standard technique finding classes training set traditional methods find points necessarily space classes central class lower error rate points algorithms finding central tested data sets frequently practice modified relaxation algorithms defined paper found good pattern recognition pattern classification linear central criteria relaxation relaxation dh april
logic semantic networks extended form semantic network defined syntactic form logic relationship logic extended semantic network provided precise semantics inference rules interpretation hand semantic networks abstract data structure representation provide theorem indexing scheme path strategy search proof logic semantic networks theorem proving indexing resolution logic programming dh april
normal multiplication tables information storage retrieval paper describes method organization retrieval attribute based information systems normal multiplication table directory information algorithms organization retrieval information method suitable queries group information items set possibly examples results respect number disk accesses disk space compared common approaches algorithms evaluating approach information class information systems normal multiplication table method yields rapid retrieval space requirement conventional systems method improved modification inverted file technique information retrieval inverted files retrieval file normal multiplication table queries rapid retrieval space economy dh
detection dimensional patterns structures detecting occurrences dimensional pattern objects larger structure presented search technique presented geometric structure pattern define characteristics matching cases properties considered number sets applications technique field searching common similar activities ray fitting structure structural set density distribution fourier map documentation retrieving file structures april dimensional pattern recognition structure search information retrieval structure analysis analysis design dh
price performance patterns systems models developed study relationships price hardware performance single measures price performance law shown simplified multiple regression models cost function hardware characteristics hand exists stable price larger general purpose systems developing small business systems low price april price performance law dh
methodology design distributed information systems macro model distributed information presented model describes major costs information perspective end user making effect design operating parameters cost transaction technique illustrated application design interactive transaction processing april distributed processing design cost minimization distributed database interactive computing economic modeling transaction processing dh
mathematical programming updating method modified transformations applied problems efficient numerically stable method presented problem updating orthogonal decomposition matrix column row vectors fundamental idea column row additional row data linear squares problem column row formal unit squares addition column row elimination process procedure successive application transformation modified efficient form ideas illustrated implementation revised simplex method general purpose account structure equations suggested computational tests determining parameters revised simplex mentioned simple means constructing test cases sample computing times presented april linear programming numerical linear algebra modified transformations linear programming test cases dh
methods vertices graph paper describes efficient heuristic methods vertices graph comparison structure graph method developed exact graphs important part heuristic procedures find general graphs finally exact method brown larger graphs heuristic methods classical methods exact method compared april complete graph structure graph scheduling comparison methods dh june
social processes proofs theorems programs argued formal programs obtained key role development science software engineering proofs mathematics change complexity specification significantly real programs make form verification process difficult ease formal verification program language design perlis formal mathematics mathematical proofs program verification program specification dh june
improved finding circular configurations processes note presents improvement finding set processes central exists number processes technique selective message order achieve average number message order log algorithms distributed systems operating systems dh june
difficulties computerized empirical investigation errors encountered end computerized process type errors occur easily errors correct designers large management packages data results show present state approximately percent average types experience errors percent attempts correct errors difficult successful appears conflict organizations public role man packages including software management systems results survey number designs large linked program packages eft errors systems errors errors management systems dh june
arrays variety concepts presented facilitate arrays basic concepts include intervals partitions functional restriction images extension relations ordering single point variation functions equivalence relations array values effectiveness ideas illustrated descriptions algorithms binary search merging short formal proof arrays assertions program proving intervals partitions extension ordering binary search merging dh june
model discussion multi interpreter systems multi interpreter programs execute programs nested interpreters run directly machine model interpreters procedures protection domains multiprocessor interpreters transfer control hierarchies dh august
implementation structured teaching cobol programming effectiveness structured teaching cobol programming sample graduate business administration cobol measured final examination testing knowledge language rules ability read program ability write program analysis multiple covariance statistically test conditional provide empirical support incorporating structured programming learning process effectively develop student writing cobol programs june structured cobol programming teaching programming testing programming dh august
academic program providing training software engineering academic program called program industry studied solved student objective provide students working small work real world problems sufficient complexity program students essential software engineering work software project management software design methodology communication environment sample software experience shown program transition academic world june software engineering software engineering education software student software engineering dh august
model file program design business application systems paper discusses model finding efficient implementation business application logical specifications determined model file program design problem configurations computations forward search technique determine computations device organization key order data set key order computation access method computation pair computational results presented sample problem involving computations main point paper underlying model computationally simple file design situations june design automatic programming search methods configurations design dh august
high level programming distributed computing programming distributed systems problem interest paper describes approach distributed computing level general purpose programming languages based primitive message transaction key methodology shown independent languages machines appears programming wide range tasks part program development advanced programming languages relations aspects project discussed june distributed computing modules messages assertions dh august
cyclic order property vertices aid analysis cyclic order property defined bounded smooth property shown analyzing pictures line data pictures property previously rules determine existence dimensional dimensional line structure data june analysis cyclic order artificial intelligence dimensional reconstruction picture processing graphics pattern recognition dh august
programming languages technology ability create large systems leading basic nature programming current programming language concepts building maintaining systems complexity called tasks attempt high level languages programmer machine order code higher level programming systems provide means manipulate complex systems components order develop systems shift attention detailed specification algorithms description properties packages objects paper programming languages exist directions future research july programming programming languages programming systems systems development dh august
optimal real time convex construction real time convex set points plane data structure constructs convex successive time log total processing time log july computational geometry convex set points real time algorithms line algorithms dh august
storage reorganization techniques matrix computation paging environment order matrices minimizing number page required efficient data form block multiplication algorithms matrices stored row column oriented form efficient method reorganization makes derivation bound multiplication matrices row oriented form technique data reorganization block multiplication scheme shown matrices pages size scheme shown matrices additional cost july matrix multiplication paging virtual memory data reorganization dh august
control response times multi class systems memory possibility quality service jobs classes memory allocation examined context paged algorithms partition main memory classes jobs considered closed process paging file devices fixed numbers jobs studied determine optimal multiprogramming processor time class decomposition approach closed single response times open external studied object effect memory parameters expected response times algorithms numerical solutions lower bounds expected response times functions control parameters obtained results systems job classes july queueing networks paging virtual memory performance control dh august
logic control logic component knowledge solving problems control component determines problem solving strategies means knowledge logic component determines meaning control component efficiency efficiency improving control component changing logic programs correct easily improved modified logic control aspects identified program text july control language logic programming nonprocedural language programming methodology program specification relational data structures dh september
programming august floyd db january
computing connected components parallel computers present parallel processors find connected components graph vertices time time bound achieved processors find symmetric boolean matrix processors access common memory simultaneous access location permitted instructions store instructions august graph theory parallel processing algorithms connected component db january
proving termination common tool proving termination programs set set ordered infinite sequences basic approach find termination function maps values program variables set termination function reduced computation termination functions required difficult find complexity program consideration set sets multiple occurrences elements ordering ordering finite ordering shown ordering enables simple termination functions difficult termination proofs ordering prove termination production systems programs defined terms sets rules august program correctness program termination program verification sets production systems term systems tree replacement systems reduction rules db january
secure computing network method implementing secure computing network central facilities proposed method employs public key encryption device hardware keys user security security central facility communication user store files central facility data users network august denning computing security privacy networks public key encryption db january
updating standard deviation estimates august standard deviation db january
experimental science report based results november authors report bell digital equipment corporation galler university ibm corporation university bell telephone technology government addition authors number people contents report preparation original science comments suggestions problems experimental science version current report january number government groups authors final version large number people preparation report note presentation report position paper experimental science written acm executive committee september db january
acm executive committee position experimental science september denning db january
improving worst case running time moore string matching shown moore string matching worst case running time linear multiple occurrences pattern present text september computational complexity linear time worst case string matching db january
optimal insertion sided height balanced binary search trees element sided height balanced binary search tree presented operates time log number nodes tree represents improvement previous insertion algorithms require time log 2n log complexity optimal earlier results shown deletion structure performed log time result paper answer question trees examples kind deletion smaller time complexity insertion concluded insertion deletion retrieval trees performed time operations general avl trees constant factor insertion deletion algorithms trees complicated algorithms avl trees september insertion sided height balanced trees height balanced trees binary trees search trees db january
tool database accepts requests graph state request cycle nodes process important areas database implementation constraints sequences actions algorithms presented simple path matrix representation list artificial experiments suggest large considerably faster number nodes expected number nodes paths node september list processing data structures topological sort database network deadlock db january
approximation polygonal maps cellular maps approximation polygonal maps cellular maps important operation data processing analyzed data organization representing polygonal maps widely segment based data structure class identify regions segment side approximation presented operates organization recognition region segment examined organization illustrated outline algorithms area computation point inclusion applied set maps form means coordinate september polygon maps data structures computational geometry automated db january
computing standard accuracy algorithms numerical computation standard deviation data analyzed algorithms statistical computational literature algorithms specifically intended automatic computation discussion emphasis suitable definition accuracy algorithms analyzed conditions accurate algorithms provide accurate problems algorithms substantially accurate difficult problems september standard deviation squares updating estimates rounding error analysis condition number db january
updating variance estimates improved method method improved efficiency updating variance weighted data additional data included set evidence presented method stable accurate existing updating method september standard deviation variance updating estimates data db january
comment optimal evaluation boolean expressions online query october query boolean expression information retrieval file organization db january
note optimal evaluation boolean expressions online query october query boolean expression optimal evaluation information retrieval db january
proof correctness calendar program formal specification simple calendar program derivation proof correctness program specification easy correctness october program specification program verification inductive assertions db january
line numbers made technique run time line number administration implementations high level languages suitable method requires overhead time space execution program october line number administration diagnostic messages abstract machine code db january
planning free paths paper describes planning path object moving objects transforms represent positions arbitrary reference point moving object reference point regions free found searching network vertices october path finding free paths objects graph searching objects db january
learning basic paper addresses question learning basic programming underlying conceptual structures identified transaction event occurs involves operation object location set line code frequently configurations lines code november basic learning instruction db january
security case history paper describes history design security scheme accessed time sharing present design result observed attempts result security ease november morris operating systems security db january
substitution relaxation substitution codes fixed word change paper problem substitution represented probabilistic problem code assigned probabilities representing text letters probabilities parallel code letters probabilities updating scheme results improved estimates finally lead method successfully examples november substitution probabilistic classification relaxation db january
storing sparse table problem storing searching large sparse tables science standard technique storing tables hashing hashing worst case performance good worst case method storing static table entries integer method requires words storage access time method complicated practice analysis shows simpler lr parsing tables november gaussian elimination parsing searching sparse matrix table compression table db january
share paper show data easily complete knowledge information technique enables construction key management schemes systems function half security november key management interpolation db january
introduction eft december db
eft large scale eft potential solution current problems generate problems presents selected papers eft society research needed future december eft research results public policy db
costs current industry public policy good information comparative costs alternative systems eft result eft systems services implemented valid cost terms criteria december eft costs db
public protection education eft research existence lack knowledge eft business government result effort public decisions introduction eft systems require educational effort considerable scale addition research present defining article presents alternatives improving current research needed actions changing environment december long electronic transfer systems education security privacy reliability eft db
caused hypothesis provided greater accuracy error electronic transfer systems discussed light technical capabilities potential caused business manual service systems characteristics resulting technological scope security issues examined factors requirements actions give research solutions related december security errors positions db
policy values eft research research recognition eft systems potential transfer american society number involved evolution values significantly depending individual conflicts part research technological issues eft eft people economic impact eft control eft evaluating monitoring eft systems december research conflicts people economic control monitoring eft db
revised report algorithmic language algol report complete defining description algorithmic language algol language suitable large class numerical processes form sufficiently direct automatic translation language programmed automatic computers january es
programmer programming job provided approach task full difficulty provided programming languages provided respect limitations human approach task programmers october dijkstra es
statement dijkstra statement jump instruction instruction conditional program program sequencing es
certification compiled run correction translator cdc comparison average sorting items recently published algorithms superior performance es
programming languages based paper dimension point language aspects semantics cover project aspects dimension strong today es
algebraic compiler fortran assembly program algebraic compiler written added fortran assembly program compiler algebraic statements operations addition multiplication division compile multi level expressions floating point arithmetic easily revised fixed point november es
correction scale ibm page typical instruction mix discussed timing computed outlined page programming error times resulting regression equation slightly error es
generating permutations nested purpose give due comment hill programs permutations june permutations es
keyboard typewriter keyboard designed computers input flexibility typewriter keyboard direct punched paper tape input usual keyboard characters chosen programmers keyboard expected facilitate programming algorithmic process considerable flexibility assembly utility routines july es
work progress formula coding technique allowing direct entry character modified automatic half line permit completely general july es
heuristic program proving elementary logical theorems paper discusses problems involved designing device capable speech events language problems analysis pointed january es
acm policy standardization periodic change results change policy case department change proper time acm policy respect standardization area november es
typewriter program character keyboard including upper lower case good machine restricted single case lower case typewriter typewriter operate type telephone line lines january es
structures standards processing organizations area line acm policy statement comm acm descriptions provided order describe standardization activities pertinent computers information processing june bemer es
microprogramming programming languages problem concerned converting language action mechanical medium purpose language subject language areas language investigation syntax semantics es
algebraic package written slip fortran iv map ii manipulate algebraic expressions basic algebraic operations division capable handling number single variables variable finding common factor polynomials included functions substitution differentiation determining coefficients variables solving linear equation basic routines special purpose arithmetic routines major assignment types expressions standard ordering procedure august gotlieb es
formac program solution linear boundary initial problems program developed obtaining approximate solutions linear initial boundary problems involving differential equations problem input program includes equations symbolic form satisfied differential equations equations describing auxiliary conditions boundary conditions numerical description regions equations satisfied sets functions symbolic form linear combinations approximate solution functions give input program generates approximation solutions terms functions optimum squares sense august es
symbolic manipulation poisson series poisson series variables set formal subroutines written partially ibm machine language called fortran language fortran programs effort made operations required routines contained subroutines require standard fortran input output units design avoid overflow core storage space august es
algebra analytic differentiation mathematical expression written fortran notation stored string characters complicated desired nested restriction long entire expression subsequent form characters performing algebraic operations obtaining analytic derivatives manipulating character sequences programs written fortran iv cdc discussed detail august es
program symbolic algebraic manipulation differentiation general recursive algebra differentiation development set lisp functions manipulate algebraic expressions designed large amount routine manipulation program human external complicated expressions involving nested functions yield completely present version proved august es
line program numerical algebra goal program make step design automated mathematical requirements program easy access result obtained short time program written time shared development corporation chosen lisp compiler programming debugging remote console university august es