Mingliang Wang

I am currently a PhD candidate in the Electrical and Computer Engineering department at Rutgers University. My advisor is Dr. Manish Parashar.

Research

My research is to create a programming system to support hierarchical array based application programming. The goal is to provide a domain-specific high-level programming languages which allows application programmers to easily develop and maintain their multi-scale, hierarchical structured applications. By using this high-level programming language, many low-level details such as data distribution, communication, synchronization are hidden from application programmers. Programmers can hence put most of their effort in their application logic.

Past Projects

  • Orbit + PlanetLab This project is related to creating a virtulized environment on ORBIT and Planet Lab to drive the design and implementation of production wired/wirelss experimentation facility and associated tools and services, to demonstrate that such a facility can enable research, development and validation in this important class of application and to define metrics and measurement and experimentation mechanism that are meaningful in such envirnoment.

    Current Reading List

    QuickSearch:   Number of matching entries: 0.

    AuthorTitleYearJournal/ProceedingsReftypeDOI/URL
    Backus, J. Can programming be liberated from the von Neumann style?: a functional style and its algebra of programs

    [BibTeX]

    		 1978 Commun. ACM   article DOI  
    BibTeX: 
    @article{359579,
  author = {John Backus},
  title = {Can programming be liberated from the von Neumann style?: a functional style and its algebra of programs},
  journal = {Commun. ACM},
  publisher = {ACM Press},
  year = {1978},
  volume = {21},
  number = {8},
  pages = {613--641},
  doi = {http://doi.acm.org/10.1145/359576.359579}
}
    Callahan, D., Chamberlain, B. & Zima, H. The cascade high productivity language

    [Abstract] [BibTeX]

    		 2004 High-Level Parallel Programming Models and Supportive Environments, 2004. Proceedings. Ninth International Workshop on   inproceedings URL  
    Abstract: The strong focus of recent high end computing efforts on performance has resulted in a low-level parallel programming paradigm characterized by explicit control over message-passing in the framework of a fragmented programming model. In such a model, object code performance is achieved at the expense of productivity, conciseness, and clarity. This paper describes the design of Chapel, the cascade high productivity language, which is being developed in the DARPA-funded HPCS project Cascade led by Cray Inc. Chapel pushes the state-of-the-art in languages for HEC system programming by focusing on productivity, in particular by combining the goal of highest possible object code performance with that of programmability offered by a high-level user interface. The design of Chapel is guided by four key areas of language technology: multithreading, locality-awareness, object-orientation, and generic programming. The Cascade architecture, which is being developed in parallel with the language, provides key architectural support for its efficient implementation.
    BibTeX: 
    @inproceedings{Callahan2004,
  author = {Callahan, D. and Chamberlain, B.L. and Zima, H.P.},
  title = {The cascade high productivity language},
  booktitle = {High-Level Parallel Programming Models and Supportive Environments, 2004. Proceedings. Ninth International Workshop on},
  year = {2004},
  pages = {52--60},
  url = {http://ieeexplore.ieee.org/search/srchabstract.jsp?arnumber=1299190&isnumber=28865&punumber=9093&k2dockey=1299190@ieeecnfs&query=%28%28the+cascade+high+productivity+language%29%3Cin%3Emetadata%29&pos=0}
}
    Cantonnet, F., El-Ghazawi, T. A., Lorenz, P. & Gaber, J. Fast Address Translation Techniques for Distributed Shared Memory Compilers

    [Abstract] [BibTeX]

    		 2005 IPDPS '05: Proceedings of the 19th IEEE International Parallel and Distributed Processing Symposium (IPDPS'05) - Papers   inproceedings DOI  
    Abstract: The Distributed Shared Memory (DSM) model is designed to leverage the ease of programming of the shared memory paradigm, while enabling the highperformance by expressing locality as in the messagepassing model. Experience, however, has shown that DSM programming languages, such as UPC, may be unable to deliver the expected high level of performance. Initial investigations have shown that among the major reasons is the overhead of translating from the UPC memory model to the target architecture virtual addresses space, which can be very costly. Experimental measurements have shown this overhead increasing execution time by up to three orders of magnitude. Previous work has also shown that some of this overhead can be avoided by hand-tuning, which on the other hand can significantly decrease the UPC ease of use. In addition, such tuning can only improve the performance of local shared accesses but not remote shared accesses. Therefore, a new technique that resembles the Translation Look Aside Buffers (TLBs) is proposed here. This technique, which is called the Memory Model Translation Buffer (MMTB) has been implemented in the GCC-UPC compiler using two alternative strategies, full-table (FT) and reduced-table (RT). It will be shown that the MMTB strategies can lead to a performance boost of up to 700%, enabling ease-of-programming while performing at a similar performance to hand-tuned UPC and MPI codes.
    BibTeX: 
    @inproceedings{Cantonnet2005,
  author = {Francois Cantonnet and Tarek A. El-Ghazawi and Pascal Lorenz and Jaafer Gaber},
  title = {Fast Address Translation Techniques for Distributed Shared Memory Compilers},
  booktitle = {IPDPS '05: Proceedings of the 19th IEEE International Parallel and Distributed Processing Symposium (IPDPS'05) - Papers},
  publisher = {IEEE Computer Society},
  year = {2005},
  pages = {52.2},
  doi = {http://dx.doi.org/10.1109/IPDPS.2005.219}
}
    Charles, P., Grothoff, C., Saraswat, V., Donawa, C., Kielstra, A., Ebcioglu, K., von Praun, C. & Sarkar, V. X10: an object-oriented approach to non-uniform cluster computing

    [Abstract] [BibTeX]

    		 2005 OOPSLA '05: Proceedings of the 20th annual ACM SIGPLAN conference on Object oriented programming, systems, languages, and applications   inproceedings DOI  
    Abstract: It is now well established that the device scaling predicted by Moore's Law is no longer a viable option for increasing the clock frequency of future uniprocessor systems at the rate that had been sustained during the last two decades. As a result, future systems are rapidly moving from uniprocessor to multiprocessor configurations, so as to use parallelism instead of frequency scaling as the foundation for increased compute capacity. The dominant emerging multiprocessor structure for the future is a Non-Uniform Cluster Computing (NUCC) system with nodes that are built out of multi-core SMP chips with non-uniform memory hierarchies, and interconnected in horizontally scalable cluster configurations such as blade servers. Unlike previous generations of hardware evolution, this shift will have a major impact on existing software. Current OO language facilities for concurrent and distributed programming are inadequate for addressing the needs of NUCC systems because they do not support the notions of non-uniform data access within a node, or of tight coupling of distributed nodes.We have designed a modern object-oriented programming language, X10, for high performance, high productivity programming of NUCC systems. A member of the partitioned global address space family of languages, X10 highlights the explicit reification of locality in the form of places; lightweight activities embodied in async, future, foreach, and ateach constructs; a construct for termination detection (finish); the use of lock-free synchronization (atomic blocks); and the manipulation of cluster-wide global data structures. We present an overview of the X10 programming model and language, experience with our reference implementation, and results from some initial productivity comparisons between the X10 and Java™ languages.
    BibTeX: 
    @inproceedings{Charles2005,
  author = {Philippe Charles and Christian Grothoff and Vijay Saraswat and Christopher Donawa and Allan Kielstra and Kemal Ebcioglu and Christoph von Praun and Vivek Sarkar},
  title = {X10: an object-oriented approach to non-uniform cluster computing},
  booktitle = {OOPSLA '05: Proceedings of the 20th annual ACM SIGPLAN conference on Object oriented programming, systems, languages, and applications},
  publisher = {ACM Press},
  year = {2005},
  pages = {519--538},
  doi = {http://doi.acm.org/10.1145/1094811.1094852}
}
    Coarfa, C., Dotsenko, Y., Mellor-Crummey, J., Cantonnet, F., El-Ghazawi, T., Mohanti, A., Yao, Y. & Chavarra-Miranda, D. An evaluation of global address space languages: co-array fortran and unified parallel C

    [Abstract] [BibTeX]

    		 2005 PPoPP '05: Proceedings of the tenth ACM SIGPLAN symposium on Principles and practice of parallel programming   inproceedings DOI  
    Abstract: Co-array Fortran (CAF) and Unified Parallel C (UPC) are two emerging languages for single-program, multiple-data global address space programming. These languages boost programmer productivity by providing shared variables for inter-process communication instead of message passing. However, the performance of these emerging languages still has room for improvement. In this paper, we study the performance of variants of the NAS MG, CG, SP, and BT benchmarks on several modern architectures to identify challenges that must be met to deliver top performance. We compare CAF and UPC variants of these programs with the original Fortran+MPI code. Today, CAF and UPC programs deliver scalable performance on clusters only when written to use bulk communication. However, our experiments uncovered some significant performance bottlenecks of UPC codes on all platforms. We account for the root causes limiting UPC performance such as the synchronization model, the communication efficiency of strided data, and source-to-source translation issues. We show that they can be remedied with language extensions, new synchronization constructs, and, finally, adequate optimizations by the back-end C compilers.
    BibTeX: 
    @inproceedings{Coarfa2005,
  author = {Cristian Coarfa and Yuri Dotsenko and John Mellor-Crummey and Fran\c{c}ois Cantonnet and Tarek El-Ghazawi and Ashrujit Mohanti and Yiyi Yao and Daniel Chavarr\'{\i}a-Miranda},
  title = {An evaluation of global address space languages: co-array fortran and unified parallel C},
  booktitle = {PPoPP '05: Proceedings of the tenth ACM SIGPLAN symposium on Principles and practice of parallel programming},
  publisher = {ACM Press},
  year = {2005},
  pages = {36--47},
  doi = {http://doi.acm.org/10.1145/1065944.1065950}
}
    Consortium, U. UPC Language Specifications, v1.2

    [BibTeX]

    		 2005   techreport URL  
    BibTeX: 
    @techreport{LBNL-59208,
  author = {UPC Consortium},
  title = {UPC Language Specifications, v1.2},
  year = {2005},
  url = {http://www.gwu.edu/~upc/pubs.html}
}
    Dally, W. J., Labonte, F., Das, A., Hanrahan, P., Ahn, J., Gummaraju, J., Erez, M., Jayasena, N., Buck, I., Knight, T. J. & Kapasi, U. J. Merrimac: Supercomputing with Streams

    [Abstract] [BibTeX]

    		 2003 SC '03: Proceedings of the 2003 ACM/IEEE conference on Supercomputing   inproceedings URL  
    Abstract: Merrimac uses stream architecture and advanced interconnection networks to give an order of magnitude more performance per unit cost than cluster-based scientific computers built from the same technology. Organizing the computation into streams and exploiting the resulting locality using a register hierarchy enables a stream architecture to reduce the memory bandwidth required by representative applications by an order of magnitude or more. Hence a processing node with a fixed bandwidth (expensive) can support an order of magnitude more arithmetic units (inexpensive). This in turn allows a given level of performance to be achieved with fewer nodes (a 1-PFLOPS machine, for example, with just 8,192 nodes) resulting in greater reliability, and simpler system management. We sketch the design of Merrimac, a streaming scientific computer that can be scaled from a $20K 2 TFLOPS workstation to a $20M 2 PFLOPS supercomputer and present the results of some initial application experiments on this architecture.
    BibTeX: 
    @inproceedings{Dally2003,
  author = {William J. Dally and Francois Labonte and Abhishek Das and Patrick Hanrahan and Jung-Ho Ahn and Jayanth Gummaraju and Mattan Erez and Nuwan Jayasena and Ian Buck and Timothy J. Knight and Ujval J. Kapasi},
  title = {Merrimac: Supercomputing with Streams},
  booktitle = {SC '03: Proceedings of the 2003 ACM/IEEE conference on Supercomputing},
  publisher = {IEEE Computer Society},
  year = {2003},
  pages = {35},
  url = {http://portal.acm.org/citation.cfm?id=1050187&coll=Portal&dl=GUIDE&CFID=23609067&CFTOKEN=80716580}
}
    Dean, J. & Ghemawat, S. MapReduce: Simplified Data Processing on Large Clusters

    [Abstract] [BibTeX]

    		 2004 OSDI'04: Sixth Symposium on Operating System Design and Implementation   inproceedings URL  
    Abstract: MapReduce is a programming model and an associated implementation for processing and generating large data sets. Users specify a map function that processes a key/value pair to generate a set of intermediate key/value pairs, and a reduce function that merges all intermediate values associated with the same intermediate key. Many real world tasks are expressible in this model, as shown in the paper.

    Programs written in this functional style are automatically parallelized and executed on a large cluster of commodity machines. The run-time system takes care of the details of partitioning the input data, scheduling the program's execution across a set of machines, handling machine failures, and managing the required inter-machine communication. This allows programmers without any experience with parallel and distributed systems to easily utilize the resources of a large distributed system.

    Our implementation of MapReduce runs on a large cluster of commodity machines and is highly scalable: a typical MapReduce computation processes many terabytes of data on thousands of machines. Programmers find the system easy to use: hundreds of MapReduce programs have been implemented and upwards of one thousand MapReduce jobs are executed on Google's clusters every day.
    BibTeX: 
    @inproceedings{Dean2004,
  author = {Jeffrey Dean and Sanjay Ghemawat},
  title = {MapReduce: Simplified Data Processing on Large Clusters},
  booktitle = {OSDI'04: Sixth Symposium on Operating System Design and Implementation},
  year = {2004},
  url = {http://labs.google.com/papers/mapreduce.html}
}
    El-Ghazawi, T. & Smith, L. UPC: unified parallel C

    [Abstract] [BibTeX]

    		 2006 SC '06: Proceedings of the 2006 ACM/IEEE conference on Supercomputing   article DOI  
    Abstract: UPC extends ISO C into a Partioned Global Address Space (PGAS) programming language. UPC allows programmers to exploit data locality and parallelism in their applications, while maintaining ease of use. UPC is running ubiquitously across nearly all HPC platforms and has been gaining rising support from the community. UPC is relatively very easy to use for irregular access patterns which can enable many new applications that are hard to express in other paradigms. In this BoF, the UPC consortium will share with the community the progress made in applications, specifications, tools, and implementations of UPC. Future plans will be also presented. The First half of the BOF will follow a panel format, where the members will represent the UPC consortium and will speak to different aspects of the UPC developments. The second half will be a question and answer session to promote the exchange of ideas.
    BibTeX: 
    @article{El-Ghazawi2006,
  author = {Tarek El-Ghazawi and Lauren Smith},
  title = {UPC: unified parallel C},
  booktitle = {SC '06: Proceedings of the 2006 ACM/IEEE conference on Supercomputing},
  publisher = {ACM Press},
  year = {2006},
  pages = {27},
  doi = {http://doi.acm.org/10.1145/1188455.1188483}
}
    Guy L. Steele, J. Parallel programming and code selection in fortress

    [Abstract] [BibTeX]

    		 2006 PPoPP '06: Proceedings of the eleventh ACM SIGPLAN symposium on Principles and practice of parallel programming   inproceedings DOI  
    Abstract: As part of the DARPA program for High Productivity Computing Systems, the Programming Language Research Group at Sun Microsystems Laboratories is developing Fortress, a language intended to support large-scale scientific computation with the same level of portability that the Java programming language provided for multithreaded commercial applications. One of the design principles of Fortress is that parallelism be encouraged everywhere; for example, it is intentionally just a little bit harder to write a sequential loop than a parallel loop. Another is to have rich mechanisms for encapsulation and abstraction; the idea is to have a fairly complicated language for library writers that enables them to write libraries that present a relatively simple set of interfaces to the application programmer. Thus Fortress is as much a framework for language developers as it is a language for coding scientific applications. We will discuss ideas for using a rich parameterized polymorphic type system to organize multithreading and data distribution on large parallel machines. The net result is similar in some ways to data distribution facilities in other languages such as HPF and Chapel, but more open-ended, because in Fortress the facilities are defined by user-replaceable and -extendable libraries rather than wired into the compiler. A sufficiently rich type system can take the place of certain kinds of flow analysis to guide certain kinds of code selection and optimization, again moving policymaking out of the compiler and into libraries coded in the Fortress source language.
    BibTeX: 
    @inproceedings{Guy2006,
  author = {Guy L. Steele, Jr.},
  title = {Parallel programming and code selection in fortress},
  booktitle = {PPoPP '06: Proceedings of the eleventh ACM SIGPLAN symposium on Principles and practice of parallel programming},
  publisher = {ACM Press},
  year = {2006},
  pages = {1--1},
  doi = {http://doi.acm.org/10.1145/1122971.1122972}
}
    Lee, E. The problem with threads

    [Abstract] [BibTeX]

    		 2006 Computer   article URL  
    Abstract: For concurrent programming to become mainstream, we must discard threads as a programming model. Nondeterminism should be judiciously and carefully introduced where needed, and it should be explicit in programs. In general-purpose software engineering practice, we have reached a point where one approach to concurrent programming dominates all others namely, threads, sequential processes that share memory. They represent a key concurrency model supported by modern computers, programming languages, and operating systems. In scientific computing, where performance requirements have long demanded concurrent programming, data-parallel language extensions and message-passing libraries such as PVM, MPI, and OpenMP dominate over threads for concurrent programming. Computer architectures intended for scientific computing often differ significantly from so-called general-purpose architectures.
    BibTeX: 
    @article{Lee2006,
  author = {Lee, E.A.},
  title = {The problem with threads},
  journal = {Computer},
  year = {2006},
  volume = {39},
  number = {5},
  pages = {33--42},
  url = {http://ieeexplore.ieee.org/search/srchabstract.jsp?arnumber=1631937&isnumber=34216&punumber=2&k2dockey=1631937@ieeejrns&query=%28%28the+problem+with+threads%29%3Cin%3Emetadata%29&pos=0}
}
    Müller, A. & Rühl, R. Extending high performance Fortran for the support of unstructured computations

    [BibTeX]

    		 1995 ICS '95: Proceedings of the 9th international conference on Supercomputing   inproceedings DOI  
    BibTeX: 
    @inproceedings{Muller1995,
  author = {Andreas M\"{u}ller and Roland R\"{u}hl},
  title = {Extending high performance Fortran for the support of unstructured computations},
  booktitle = {ICS '95: Proceedings of the 9th international conference on Supercomputing},
  publisher = {ACM Press},
  year = {1995},
  pages = {127--136},
  doi = {http://doi.acm.org/10.1145/224538.224552}
}
    McColl, W. BSP Programming

    [BibTeX]

    		 1994 DIMACS Series in Discrete Mathematics and Theoretical Computer Science   inproceedings  
    BibTeX: 
    @inproceedings{McColl1994,
  author = {W.F. McColl},
  title = {BSP Programming},
  booktitle = {DIMACS Series in Discrete Mathematics and Theoretical Computer Science},
  year = {1994},
  volume = {00,0000}
}
    Numrich, R. W. & Reid, J. Co-array Fortran for parallel programming

    [Abstract] [BibTeX]

    		 1998 SIGPLAN Fortran Forum   article DOI  
    Abstract: Co-Array Fortran, formerly known as F--, is a small extension of Fortran 95 for parallel processing. A Co-Array Fortran program is interpreted as if it were replicated a number of times and all copies were executed asynchronously. Each copy has its own set of data objects and is termed an image. The array syntax of Fortran 95 is extended with additional trailing subscripts in square brackets to give a clear and straightforward representation of any access to data that is spread across images.References without square brackets are to local data, so code that can run independently is uncluttered. Only where there are square brackets, or where there is a procedure call and the procedure contains square brackets, is communication between images involved.There are intrinsic procedures to synchronize images, return the number of images, and return the index of the current image.We introduce the extension; give examples to illustrate how clear, powerful, and flexible it can be; and provide a technical definition.
    BibTeX: 
    @article{Numrich1998,
  author = {Robert W. Numrich and John Reid},
  title = {Co-array Fortran for parallel programming},
  journal = {SIGPLAN Fortran Forum},
  publisher = {ACM Press},
  year = {1998},
  volume = {17},
  number = {2},
  pages = {1--31},
  doi = {http://doi.acm.org/10.1145/289918.289920}
}
    Papadopoulos, G. A. & Arbab, F. Coordination models and languages

    [Abstract] [BibTeX]

    		 1998   techreport URL  
    Abstract: A new class of models, formalisms and mechanisms has recently evolved for describing concurrent and distributed computations based on the concept of ``coordination''''. The purpose of a coordination model and associated language is to provide a means of integrating a number of possibly heterogeneous components together, by interfacing with each component in such a way that the collective set forms a single application that can execute on and take advantage of parallel and distributed systems. In this chapter we initially define and present in sufficient detail the fundamental concepts of what constitutes a coordination model or language. We then go on to classify these models and languages as either ``data-driven'''' or ``control-driven'''' (also called ``process-'''' or ``task-oriented''''). Next, the main existing coordination models and languages are described in sufficient detail to let the reader appreciate their features and put them into perspective with respect to each other. The chapter ends with a discussion comparing the various models and some conclusions.
    BibTeX: 
    @techreport{Papadopoulos1998,
  author = {George A. Papadopoulos and Farhad Arbab},
  title = {Coordination models and languages},
  publisher = {CWI (Centre for Mathematics and Computer Science)},
  year = {1998},
  url = {http://portal.acm.org/citation.cfm?id=869262&coll=GUIDE&dl=GUIDE&CFID=28123915&CFTOKEN=11865517#}
}
    Pike, R., Dorward, S., Griesemer, R. & Quinlan, S. Interpreting the data: Parallel analysis with Sawzall

    [Abstract] [BibTeX]

    		 2005 Sci. Program.   article URL  
    Abstract: Very large data sets often have a flat but regular structure and span multiple disks and machines. Examples include telephone call records, network logs, and web document repositories. These large data sets are not amenable to study using traditional database techniques, if only because they can be too large to fit in a single relational database. On the other hand, many of the analyses done on them can be expressed using simple, easily distributed computations: filtering, aggregation, extraction of statistics, and so on.

    We present a system for automating such analyses. A filtering phase, in which a query is expressed using a new procedural programming language, emits data to an aggregation phase. Both phases are distributed over hundreds or even thousands of computers. The results are then collated and saved to a file. The design -- including the separation into two phases, the form of the programming language, and the properties of the aggregators -- exploits the parallelism inherent in having data and computation distributed across many machines.
    BibTeX: 
    
@article{Pike2005,
  author = {Rob Pike and Sean Dorward and Robert Griesemer and Sean Quinlan},
  title = {Interpreting the data: Parallel analysis with Sawzall},
  journal = {Sci. Program.},
  publisher = {IOS Press},
  year = {2005},
  volume = {13},
  number = {4},
  pages = {277--298},
  url = {http://labs.google.com/papers/sawzall.html}
}
    Skillicorn, D. B. & Talia, D. Models and languages for parallel computation

    [Abstract] [BibTeX]

    		 1998 ACM Comput. Surv.   article DOI  
    Abstract: We survey parallel programming models and languages using six criteria to assess their suitability for realistic portable parallel programming. We argue that an ideal model should by easy to program, should have a software development methodology, should be architecture-independent, should be easy to understand, should guarantee performance, and should provide accurate information about the cost of programs. These criteria reflect our belief that developments in parallelism must be driven by a parallel software industry based on portability and efficiency. We consider programming models in six categories, depending on the level of abstraction they provide. Those that are very abstract conceal even the presence of parallelism at the software level. Such models make software easy to build and port, but efficient and predictable performance is usually hard to achieve. At the other end of the spectrum, low-level models make all of the messy issues of parallel programming explicit (how many threads, how to place them, how to express communication, and how to schedule communication), so that software is hard to build and not very portable, but is usually efficient. Most recent models are near the center of this spectrum, exploring the best tradeoffs between expressiveness and performance. A few models have achieved both abstractness and efficiency. Both kinds of models raise the possibility of parallelism as part of the mainstream of computing.
    BibTeX: 
    @article{Skillicorn1998,
  author = {David B. Skillicorn and Domenico Talia},
  title = {Models and languages for parallel computation},
  journal = {ACM Comput. Surv.},
  publisher = {ACM Press},
  year = {1998},
  volume = {30},
  number = {2},
  pages = {123--169},
  doi = {http://doi.acm.org/10.1145/280277.280278}
}

    Publications

    Journals

    • Tan, K. C., Wang, M. L. and Peng, W., 'A P2P genetic algorithm environment on the Internet', Communications of the ACM 2005.

    Book Chapters

    • Tan, K. C., Lee, T. H. and Wang, M. L., 'Computational intelligence approach to object recognition', Intelligent Control Systems Using Soft Computing Methodologies, M. Jamshidi and A. Zilouchian (Eds.), CRC Press, 2000.

    Conference Papers

    • K. C. Tan, M. L. Wang, W. Peng (2004). A P2P Network Architecture Embedded With GA, Communication Systems, Networks and Digital Signal Processing, Forth International Symposium
    • Tan, K. C., Lee, T. H., and Wang, M. L. (2000). Object recognition from multiple sensory data by neural feature extraction and fuzzy structural description, IEEE Int. Conf. on Ind. Elec., Cont. and Inst. (IECON'2000), Nagoya, Japan, 2141-2146.
    • Prahlad, V., Tan, K. C., Wang, M. L. (2000). Evolutionary artificial potential field and their application in real-time robot path planning, Congress on Evolutionary Computation 2000, La Jolla, CA, USA, 256-263.
    • Tan, K. C., Li, Y., and Wang, M. L. (2000). Linear approximation model network and its formation via evolutionary computation, Conf. on Simulated Evolution and Learning 2000 (SEAL'2000), Nagoya, Japan, 2774-2779.
    • Khor, E. F., Tan, K. C., Wang, M. L., and Lee, T. H. (2000). Evolutionary algorithm with dynamic population size for multi-objective optimization, Conf. on Simulated Evolution and Learning 2000 (SEAL'2000), Nagoya, Japan, 2768-2773.

    Contact Infomation 

    Office: 625 CoRE
Department of Electrical & Computer Engineering
Rutgers, The State University of New Jersey
94 Brett Road, Piscataway, NJ 08854-8058

Email: m l w a n g @ c a i p . r u t g e r s . e d u