Monday, October 2, 2006

搜索到的资源

(提供一些搜索到的资源,不同的网络类型可能连接的情况不同,大家可以尝试着连连看。)
转载自 新天下(福大新区)论坛

ftp://202.114.1.121
ftp://202.114.10.199
ftp://warez:cn.ftp@202.114.12.174
ftp://Music2:Music@202.114.122.194
ftp://hust:hust@202.114.22.131
ftp://202.114.22.152
ftp://202.114.22.221
ftp://hust:hust@202.114.22.9
ftp://202.114.13.74
ftp://202.114.19.188
ftp://202.114.2.4
ftp://202.114.21.10
ftp://202.38.127.114
ftp://211.69.196.136
ftp://211.69.196.1
ftp://211.69.197.133
ftp://202.114.24.206
ftp://202.114.3.232
ftp://202.114.6.104
ftp://202.114.7.21
ftp://211.69.207.156
ftp://211.69.207.26
ftp://211.69.207.30
ftp://202.114.13.195
ftp://211.69.197.36
ftp://download:download@166.111.174.8
ftp://211.69.197.84
ftp://166.111.160.7
ftp://211.69.206.183
ftp://162.105.204.170
ftp://211.69.207.127
ftp://202.114.6.108
ftp://202.114.22.221
ftp://202.114.6.161
ftp://202.112.78.5
ftp://202.114.6.51
ftp://166.111.184.48
ftp://download@166.111.175.5
ftp://202.114.20.241
ftp://202.117.1.24
ftp://202.114.3.199
ftp://202.116.95.81
ftp://202.114.4.42
ftp://202.116.0.143
ftp://202.114.6.104
ftp://hust:hust@202.114.22.9
ftp://202.114.123.12
ftp://202.119.32.36
ftp://202.114.224.35
ftp://202.119.32.33
ftp://202.114.224.37
ftp://202.118.75.65
ftp://202.114.252.46
ftp://202.118.68.70
ftp://202.114.118.11
ftp://211.66.17.72
ftp://202.114.119.131
ftp://210.34.4.6
ftp://202.114.120.51
ftp://210.34.4.5
ftp://wuhan:hello@202.114.121.31
ftp://202.38.97.230
ftp://202.112.83.168
ftp://fulldown:fulldown@211.99.204.87:3333
ftp://162.105.90.136
ftp://211.69.207.26
ftp://202.116.83.50
ftp://211.69.197.133
ftp://202.116.0.16
ftp://211.69.196.1
ftp://202.114.253.69
ftp://any:888@202.197.78.130
ftp://166.111.168.30
ftp://162.105.81.63
ftp://166.111.135.10
ftp://162.105.84.115
ftp://alibaba.dhs.org
ftp://166.111.162.116
ftp://166.111.168.6:8021
ftp://ia.hust.edu.cn
ftp://202.116.0.16
ftp://human:enjoyeden@162.105.246.216
ftp://166.111.168.11
ftp://download@ftp.jedidiah.3322.org
ftp://162.105.90.200
ftp://162.105.19.19:8021
ftp://162.105.138.198
ftp://162.105.138.194:1021
ftp://166.111.167.9
ftp://166.111.146.88
ftp://166.111.106.249
ftp://162.105.90.58
ftp://202.112.29.106
ftp://166.111.174.25
ftp://166.111.174.23
ftp://166.111.169.243
ftp://202.114.19.188
ftp://202.114.13.74
ftp://202.113.29.123
ftp://202.112.96.164
ftp://scau:scau@202.116.160.90
ftp://scau:scau@202.116.160.89
ftp://202.115.112.29
ftp://202.114.2.4
ftp://1:1@202.38.221.114
ftp://202.38.221.114
ftp://202.204.120.63
ftp://202.194.75.246
ftp://211.69.196.136
ftp://211.66.2.218
ftp://210.34.6.24
ftp://202.38.64.22
ftp://162.105.71.147
ftp://202.115.128.60
ftp://211.69.197.84
ftp://211.69.197.36
ftp://162.105.222.195
ftp://162.105.161.171
ftp://162.105.153.220
ftp://162.105.37.168
ftp://162.105.87.205
ftp://162.105.81.251
ftp://162.105.81.116
ftp://162.105.71.177
ftp://202.114.120.51
ftp://202.114.12.150
ftp://202.114.12.106
ftp://202.114.102.15
ftp://202.114.14.8
ftp://202.114.13.146
ftp://202.114.121.41
ftp://202.114.121.184
ftp://202.114.66.130
ftp://202.114.4.193
ftp://202.114.31.32
ftp://202.114.22.226
ftp://202.114.97.193
ftp://202.114.74.28
ftp://202.114.72.2
ftp://202.114.7.58
ftp://166.111.171.36
ftp://166.111.168.16
ftp://202.114.98.21
ftp://202.38.66.87
ftp://202.205.10.22
ftp://202.114.24.206
ftp://166.111.174.27
ftp://162.105.70.139
ftp://162.105.202.100
ftp://162.105.17.77
ftp://162.105.161.40
ftp://202.195.62.11
ftp://202.193.67.8
ftp://202.193.65.13
ftp://162.105.71.218
ftp://202.196.108.96
ftp://202.196.107.185
ftp://202.196.107.133
ftp://202.196.105.2
ftp://csu:139@xkx.csu.edu.cn
ftp://202.196.99.222
ftp://202.196.98.254
ftp://202.196.74.66
ftp://162.105.92.40
ftp://162.105.90.51
ftp://162.105.90.219
ftp://166.111.176.24
ftp://166.111.168.18
ftp://166.111.168.17:2121
ftp://166.111.132.166
ftp://211.80.53.1
ftp://210.34.20.68
ftp://202.116.184.142
ftp://166.111.199.8
ftp://162.105.84.16
ftp://162.105.90.166
ftp://166.111.175.4
ftp://166.111.147.51
ftp://162.105.71.147
ftp://162.105.88.46
ftp://162.105.16.219
ftp://162.105.90.174
ftp://166.111.135.10
ftp://162.105.90.174
ftp://162.105.90.166
ftp://162.105.77.144
ftp://202.115.128.60
ftp://166.111.175.4
ftp://166.111.168.30
ftp://166.111.147.51
ftp://166.111.168.12
ftp://xidu.net:123@ftp.xidu.net
ftp://211.80.53.1
ftp://pub:pub@218.197.243.103
ftp://202.38.83.57
ftp://202.120.23.4
ftp://202.120.23.3
ftp://162.105.75.232
ftp://162.105.68.205
ftp://sex:sex@202.200.233.166
ftp://202.115.137.168
ftp://202.114.3.232
ftp://202.114.22.152
ftp://162.105.90.54
ftp://162.105.22.163
ftp://162.105.204.185
ftp://162.105.77.144
ftp://202.116.64.34
ftp://162.105.70.139
ftp://202.115.44.2
ftp://162.105.76.249
ftp://162.105.71.149
ftp://162.105.203.50
ftp://162.105.19.19
ftp://162.105.140.202
ftp://166.111.172.7:8021
ftp://166.111.168.15
ftp://166.111.142.6
ftp://166.111.136.2
ftp://202.113.16.219
ftp://202.112.94.136
ftp://202.112.87.25
ftp://166.111.172.8
ftp://warez:cn.ftp@202.114.12.174
ftp://202.113.29.4
ftp://202.113.29.120
ftp://202.113.21.169
ftp://202.119.24.31
ftp://202.116.191.144
ftp://202.115.32.133
ftp://hust:hust@202.114.22.131
ftp://202.38.97.197
ftp://202.38.127.114
ftp://202.204.120.69
ftp://202.120.6.34
ftp://210.73.87.125
ftp://210.35.16.168
ftp://210.32.133.168
ftp://203.207.226.89
ftp://user@162.105.80.170
ftp://211.69.207.156
ftp://211.69.206.183
ftp://202.119.202.202
ftp://202.116.191.80
ftp://202.114.6.241
ftp://166.111.161.117
ftp://211.69.196.190:2121
ftp://211.69.196.190:8821
ftp://211.66.25.209
ftp://210.45.125.1
ftp://202.114.73.186
ftp://166.111.177.123
ftp://202.114.74.131
ftp://202.114.73.6
ftp://202.114.73.199
ftp://issloveme:issloveme@202.114.73.197
ftp://202.114.103.84
ftp://202.114.103.10
ftp://202.114.101.253
ftp://202.115.32.122
ftp://202.114.67.33
ftp://202.114.66.36
ftp://202.114.106.12
ftp://wadmin:shaoprof987@202.114.105.31
ftp://gaoya:gaoya@202.114.103.130
ftp://202.114.103.84
ftp://202.114.69.168
ftp://202.114.68.250
武汉大学校内ftp资源列表;
ftp://202.114.73.200
ftp://pole:pole@202.114.122.249
ftp://pole:pole@202.114.122.239
ftp://issloveme:issloveme@202.114.73.197
ftp://Music2:Music@202.114.122.194
ftp://gaoya:gaoya@202.114.103.130
ftp://cs:whucsftp@cs.whu.edu.cn
ftp://202.114.58.24(whut)
ftp://xp:xp@202.114.55.12(whut)
ftp://202.114.106.11
ftp://202.114.118.81
ftp://202.114.121.40
ftp://liss:liss@202.114.70.5
ftp://202.114.67.51
ftp://202.114.122.194
ftp://202.114.99.43(ziqiang)
ftp://202.114.99.40 (future)
ftp://202.114.99.37 (future)

已经测试 过的,以下均为有效链接:
ftp://202.202.121.4 西南农业大学 里面有不少的discovery
ftp://162.105.142.8 北京大学 不少的科教片
ftp://bbs:ytht@162.105.27.104 北京大学 有声文学和曲艺
ftp://162.105.30.160 北京大学信息科学学院软件工程实验室 电影
ftp://media:media@166.111.120.26 清华大学 电影
ftp://166.111.132.44 清华大学 电影
ftp://166.111.44.179 清华大学 有限元资料
ftp://202.114.106.11 武汉大学 电影和音乐
ftp://gaoya:gaoya@202.114.103.130 武汉大学高压实验室 影视
ftp://out:out@166.111.44.45 清华大学土木系 DVD
ftp://202.114.11.112 华中科技大学 软件和linux教学视频
ftp://202.114.121.40 武汉大学 专门的音乐站点
ftp://xp:xp@202.114.58.24 武汉理工大学东院图书馆 大量的电影和软件
ftp://202.114.67.51 武汉大学 电影
ftp://202.114.70.5 武汉大学 电影
ftp://issloveme:issloveme@202.114.73.197 武汉大学 DVD
ftp://202.114.73.200 武汉大学 电视剧,有老友记和24季
ftp://202.117.33.79 西安交通大学 一些电影
ftp://hit:hit@202.118.224.241 哈尔滨工业大学 大量的教学资源
ftp://202.207.240.119 太原理工大学 大量电影包括历年的oscar 需要http://final.ty
ut.edu.cn注册下载
ftp://202.207.240.168 太原理工大学 大量的电子书和教学视频
ftp://202.38.127.180 清华大学 电影
ftp://210.34.132.101 集美大学 电影和动画 密码见进站说明
ftp://210.34.212.105 鹭江大学图书馆FTP站 大量电影
ftp://211.64.86.11 济南大学法学院 电影
ftp://211.67.108.250 华中科技大学 有一些discovery
ftp://hncj.edu.cn:hncj.edu.cn@211.67.112.123:21 平顶山工学院 大量的电影
ftp://hust:hust@bigfoot.hust.edu.cn 华中科技大学的大脚网 大量的电影
ftp://cs:whucsftp@cs.whu.edu.cn 武汉大学计算机学院 电影和软件
ftp://ARK.HIT.EDU.CN 哈尔滨工业大学方舟软件园 软件
ftp://166.111.171.49:7721 清华大学 大量电影
ftp://fanfish.3322.org 清华大学 曲艺,喜欢戏剧的朋友可以看看
ftp://210.35.168.11 江西教育网 各种软件
ftp://ftp.tzpc.edu.cn 泰州职业技术学院 软件
ftp://ftp.cust.edu.cn 长春理工大学 软件、电影、音乐
ftp://ftp.xznu.edu.cn 徐州师范大学 软件、教学资源
ftp://202.114.99.37 武汉大学未来网服务器 大量DVD 需要去bbs.future.org.cn注册下载
ftp://202.114.99.40 武汉大学自强网服务器 大量电影
ftp://ftp.zzu.edu.cn 郑州大学 软件、电子书、教学视频
ftp://phoenix:phoenix@219.224.169.241 清华大学 大量名导演的代表作
ftp://movie.hn.edu.cn 中南大学 大量电影 去聊来聊去网站的bbs注册下载速度更快
ftp://jmu:jmu@210.34.132.102 集美大学 大量电影
ftp://vod.zzia.edu.cn 郑州航院 大量电影 耐心一点连
ftp://202.113.29.4 南开大学数学学院 大量的学习资料和软件
ftp://210.40.4.8 贵州大学计算机科学系 软件和书
ftp://ilovexmu:xmuloveme@210.34.4.16:21 厦门大学 大量DVD
ftp://218.198.127.4 郑州轻工业学院 电影
ftp://202.198.35.153 吉林大学车辆学院智能车辆课题组 电影
ftp://202.120.165.151 同济大学 电子书
ftp://202.116.24.102 暨南大学 漫画
ftp://ren:ren@202.112.94.88 北京师范大学 电影
ftp://202.114.122.194 武汉大学 TV有红楼梦
ftp://202.115.143.234 成都理工学院 DVD
ftp://movie:movie@162.105.36.58 北京大学 艺术电影、名导演的作品
ftp://arch.pku.edu.cn 北京大学 电影、教育资源
ftp://xmumovie:xmumovie@210.34.4.124 厦门大学 电影
ftp://temp:temp@210.34.14.166:2121 厦门大学 电影
ftp://temp:temp@210.34.14.167:2121 厦门大学 电影
ftp://tv:tv@210.34.4.14 厦门大学 TV
ftp://geming:maozedong@166.111.38.236 大量国内早期影片(如地道战、地雷战)
ftp://210.41.224.47 成都信息工程学院 电子书和软件
ftp://202.117.45.201 西安交通大学 DVD和RMVB
ftp://ftp.nju.edu.cn 南京大学 DVD 难连但是连上速度巨快
ftp://ftp2.nju.edu.cn 南京大学 影视动画 难连但是连上速度巨快
ftp://ftp.zsu.edu.cn 中山大学 综合ftp 资源丰富但是难连
ftp://ftp.ants.3322.org/ 南京电力高专 需去http://ants.3322.org注册,电影不少,呵呵,还有铁甲008这样的打小越南的片子 子
ftp://kexie:17423@166.111.132.44 北京大学化学系 DVD超级多
ftp://suepoutdown:suepoutdown@210.35.88.9 上海电力学院 电影
ftp://hust:hust@finance.hust.edu.cn 华中科技大学管理学院财政金融管理系不少电影包括周星驰和周润发的润发的

Friday, August 4, 2006

Sleepless night

I want to write a Java script to read lyric files from ttplayer's hosts. I found the way easily.


the url of TTplayer's lyric server is: http://220.181.18.92/dll/lyricsvr.dll?Artist=&Title=&Flags=0  ChinaTelecom


60.28.22.65 CNC


For example:毛阿敏 相思 http://220.181.18.92/dll/lyricsvr.dll?sh?Artist=DB6B3F964F65&Title=F8761D60&Flags=0


http://60.28.22.65/dll/lyricsvr.dll?sh?Artist=DB6B3F964F65&Title=F8761D60&Flags=0


all we need to do is to turn the String of artist and title into hex.


 String.getbytes("UTF-16LE")


But this took used up the whole night.


























Charset


Description

US-ASCIISeven-bit ASCII, a.k.a. ISO646-US, a.k.a. the Basic Latin block of the Unicode character set
ISO-8859-1  ISO Latin Alphabet No. 1, a.k.a. ISO-LATIN-1
UTF-8Eight-bit UCS Transformation Format
UTF-16BESixteen-bit UCS Transformation Format, big-endian byte order
UTF-16LESixteen-bit UCS Transformation Format, little-endian byte order
UTF-16Sixteen-bit UCS Transformation Format, byte order identified by an optional byte-order mark

Thursday, August 3, 2006

Headache and Hungry

  I have been feeling headache since this morning, or even last evening. I didn't know why, so I thought maybe I was ill.

  Was I sick? So, what's the matter? Was there anthing wrong with my head? Did I used it too much during these two days ( I slept for only 5 hours everyday working with computer), or, I catched a cold ( I weared bothing but a shorts)?


  Then, it's the time to get up. When I begain to shout loudly that I am getting up, I was suddenly awared of the reason for my headache. It's must because...


  Hungry? Yes! You are quite ringht! I felt bad just because I was hungry. I didn't have meta or egg or other nurished food. So, I feel hungey, bad, and sick.


  It's really important to have enough and rest enough If you want to do some jobs and live a happy life.

Wednesday, April 19, 2006

An Introduction to Programming Languages.bku.yang摘引



previous latest addition here








Introduction




Target Audience



This is an attempt to summarize some of the basic ideas behind
programming languages. It was originally written for "people who
know one language and are wondering about learning another", and
hasn't strayed far from that aim.



It is not a detailed, scholarly exploration of all
programming languages, nor does it describe the latest developments
(or even cover all the basics) in computer science - I simply do not
know enough to attempt that. Instead, I have tried to write something
that is clear, unbiased, and useful to someone with no knowledge of
the theory of computing.



If you're not that interested in actually writing code and are
looking for a more general article, focusing on the "philosophical"
aspects of programming languages, then you will be much happier with this book review.



Initial Questions



  • Why are there so many different programming languages?

  • What are the differences between them?

  • What are the advantages of particular languages?

  • Can a single language have all the "good bits" of other
    languages?

  • Do some "good bits" force a language to also have "bad bits"?

  • What makes a feature good or bad?

  • Is there a perfect language?

  • Is there a perfect language for a particular task?

  • What changes can we expect in the near future?



Route Map



I don't try to answer the questions above directly. Instead I look at
the various different (and rather arbitrary) families of
languages, discuss their main features, and then try to compare them
with others.


The examples I give focus on the languages I know best, but I try to
cover a wide range of different topics.


Finally, I include some links so that you can continue your own research.



Disclaimer



Be warned: I am no expert. I don't have a formal education in
computing, so this is restricted to what I have picked up "along the
way". The links at the end give other sources of information. If you
spot an error, or have an improvement, please contact me. Thanks.


I'm currently (late 2004) editing and revising this document in an
attempt to improve it a little. Please bear with me.






Language Features




Introduction



This section looks at different "features" or "tricks" that languages
provide. Presenting them in this way is misleading, because it can give
the impression that language design involves selecting which features
to implement, and then writing a compiler when, in fact, language
development is a complex process, that requires balance, compromise,
and is affected by the environment and history in which it is
implemented.



But we have to break the subject up somehow, and this seems a
reasonable way to start.



Types



Different pieces of information in a program may have different
types. For example, a language may treat a string of
characters and number in different ways (dividing a string by 3.14 may
not be possible, even if the string, when printed, is "200"). A
language like this has at least two types - one for strings and one for
numbers.



I can think of one language, Tcl, where
everything is a string, but most languages have many types.



At first, types seem fairly simple. They are a way of dividing up
things into different groups. But it can soon get much more complicated
- what if one group is "like" another group in certain ways? What is
the type of a function?



Types will reappear throughout this section.



Static and Dynamic
Typing



Types can be static or dynamic. Languages like Lisp or Python have many
different types, but when you look at a piece of code there is nothing
that forces a variables to "be" (or to "point to") a piece of data of a
particular type. In other languages, like ML or
Eiffel, a certain variable will always be
connected with a value of a certain, fixed type. The first group of
languages (where the type of everything is unknown when the program is
compiled) has dynamic types, the second group has static types.



Dynamic types are good because the program source can be more flexible
and compact (which might be particularly useful for prototyping a
system, for example). Static types are good because they allow certain
errors in programs to be detected earlier (a compiler for a statically
typed language may also be able to make extra optimisations using the
extra information available, but this depends on details of particular
languages and compilers).



My own view is that at computing projects become larger, static typing
becomes more important. I would not like to work on a project with many
other programmers using a dynamically typed language, and I choose to
use dynamically typed languages, usually, when doing projects of my
own.



In some languages (e.g. ML) the interpreter or
compiler can often work out the type associated with a variable by
itself, which saves the programmer a lot of effort.



Strong and Weak Typing



Types can be weak or strong. The languages mentioned
above are all strongly typed, which means that at any point in the
program, when it is running, the type of a particular chunk of data is
known.



Since a dynamically typed language does not have complete type
information at compile time it must, if it strongly typed, keep track
of the type of different values as it runs. Typically values are
boxed together with information about their type - value and
type are then passed around the program together.



It might seem that a strong, statically typed language would not need
to do this and so could save some memory (as type information is
available when the program is compiled). In practice, however, I
believe that they still do so - possibly because of
polymorphism (see below).



Unlike the languages mentioned so far, C has weak
typing - some variables can point to different types of data, or even
random areas of memory, and the program cannot tell what type of object
is being referred to. Depending on the context within the program, the
variable is assumed to point to some particular type, but it is quite
possible - and a common source of confusing bugs - for this assumption
to be incorrect (some type checking is done by a C
compiler, but not as much as in a language designed to have rigorous
compile time checking, like those described as statically typed above).



Java is strongly, but not statically, typed -
classes can be converted (cast) and, if the types are not
compatible (related through inheritance - see below), a run time error
will occur. Apart from this (significant) exception the Java type
system can be considered static - one description is "compromised
strong static typing".



When strong static typing is enforced (even if only partially, as in
Java) it can be difficult to write generic algorithms - functions that
can act on a range of different types. Polymorphism allows
"any" to be included in the type system. For example, the types of a
list of items are unimportant if we only want to know the length of the
list, so in ML a function can have a type that
indicates that it takes lists of "any" type and returns an integer.



Another solution to the problem of over-restrictive types is to use
inheritance from OOP (see below) to group data
together. Yet another approach, used in C++, is
templates - a way of describing generic routines which are
then automatically specialised for particular data types (generic
programming
and parameterised classes).



Object Oriented Programming



Many language support object oriented programming. In OOP data and functions are grouped together in
objects (encapsulation). An object is a particular
instance of a class. Each object can contain
different data, but all objects belonging to a class have the same
functions (called methods). So you could have a program with
many email objects, containing different messages, but they would all
have the same functionality, fixed by the email class. Objects often
restrict access to the data (data hiding).



Classes are a lot like types - the exact relationship between types and
classes can be complicated and varies from language to language.



Via inheritance, hierarchies of objects can share and modify
particular functions. You may have code in one class that describes the
features all emails have (a sender and a date, for example) and then,
in a sub-class for email containing pictures, add functions
that display images. Often in the program you will refer to an email
object as if it was the parent (super-class) because it will
not matter whether the email contains a picture, or sound, or just
text. This code will not need to be altered when you add another
sub-class of email objects, containing (say) electronic cash.



Sometimes you may want an action on a super-class to produce a result
that depends on what sub-class it "really is". For example, you may
want to display a list of email objects and want each sub-class (text,
image, etc) to display in a different colour. In many languages it is
possible for the super-class to have functions that sub-classes change
to suit their own purposes (polymorphism, implemented by the
compiler using a technique called dynamic binding). So each
email sub-class may supply an alternative to the default, printing
function, with its own colour.



In many OO languages it is possible to find out
what class an object is (run time type information) and even
what functions are connected with it (introspection /
reflection). Others, like C++ have
little run time information available (at least in the standard
language - individual libraries of objects can support RTTI
with their own conventions).



There are at least three approaches to OO
languages:




Methods in Classes



Many languages follow Smalltalk in
associating functions (methods) with classes. The methods form
part of a class definition and the language implementation will have
(this is a low-level detail hidden from the programmer) a
vtable for each class which links methods to their
implementations. This indirection is necessary to allow
polymorphism, but introduces a performance penalty. In some languages
(C++, at least), only some methods, marked as
virtual by the programmer, are treated in this way.



Multi-Methods Separate
from Classes



Some languages (e.g. common Lisp / CLOS) allow
functions to specialise on the class of any variable that they are
passed (multi-methods). Functions cannot be associated with one
class because different versions of the function may exist for many
different combinations of classes.



Prototypes



Other OO languages do away with classes
completely (e.g. Self). Prototype-based
languages create new objects using an existing object as an example
(prototype). Apart from solving some problems with dynamic
object creation, this approach also encourages delegation
(function calls are passed to other objects) rather than inheritance.



More Object Oriented
Programming



Inheritance may be restricted to a single parent (a car is a type of
vehicle, and can use methods defined for vehicles - single
inheritance
(e.g. Modula 3)) or not (a car
is a type of vehicle and a type of polluter, and can use methods
defined for both parents - multiple inheritance (e.g. C++)).



Java has a compromise between single and
multiple inheritance - it allows multiple inheritance of
interfaces (something like class types - classes can be
written to implement an interface), but only single
inheritance of classes.




When sub-classing objects, it is possible to redefine methods. In most
(contravariant) languages the argument to a more specialised
functions must be the same, or a more general class. This allows
methods on objects to be called whether the object is the declared
class or a subclass (e.g. C++, Java, Sather). But in
other (covariant) languages (e.g. Eiffel) the argument to the subclass must be
more specialised than the argument to the method in the parent. This
implies run-time errors or compiler checking, but may be more useful -
specialised classes often require specialised arguments.



One approach to software design involves specifying certain conditions
that objects must satisfy (design by contract). Conditions
might be specified before (pre-conditions), throughout
(invariants) or after (post-conditions) invoking a
method. Some languages (Eiffel led the way
here) provide support for this within the language.



Declarative
Languages



Languages can be classified as functional,
procedural or logical.



In procedural languages it is common for the same variable to keep
changing value as the program runs. These are a common source of errors
and are avoided in declarative (functional or
logical) languages.



If you are not used to declarative programming, it is difficult to see
how a program can work without variables that change value, so the
statement above sounds suspiciously like "programs are a common source
of errors". Part of the problem is that so many different ideas are
covered by the word "variables" and only some of these are eliminated
from declarative programs.



First, I am not saying that variables are not used at all - giving a
name to a value is very useful in all languages.



Second, I am not saying that a variable as it appears statically in the
source code always has one value. The return value of a function can be
different each time it is called, for example. Such variables are
created each time the function is used and destroyed again when the
function ends (the value that they return is not destroyed, but it is
not possible to assign a value to the variable inside the function
definition from outside).



Returning to declarative languages, we can now say more precisely what
they avoid - variables do not change value inside their dynamic scope.
This means no global variables that are updated to reflect how the
program has progressed, and no loop counters, but still allows named
values and different values inside different scopes (e.g. each time a
function is called, it can accept different arguments and return
different values).



One way of avoiding state variables is by passing functions
around. Instead of evaluating a certain function and then passing the
result to another part of the program, the function itself is passed
for evaluation when required. Functions that can be passed like data
are called first-class functions; a related term is higher
order functions
which describes functions that take functions as
arguments, or return functions as results.



For practical reasons many functional languages
do allow for some static data (especially for input/output - languages
which are strictly functional are termed pure).



Logical languages (Prolog, Mercury) are
collections of logical statements and questions about the relationships
they describe (although at first sight it may not seem possible to
program in this way). I'm afraid I can't say much more about them
because I've not used them much.



The advantage of declarative languages, apart from avoiding problems
with state variables, is that programs written in them are closer to
the program specification. Programming, therefore, is at a higher level
than in the imperative languages.



Functional Programming



One facility that enables functional
programming is closure - "wrapping up some state". For
example, to make a function that add 2 to numbers it is possible to
make a (nameless) function that contains the addition function and the
value (state) 2 (the nameless function is called a lambda
expression
) - this can then be used to add 2 to other numbers.
Although that example is trivial, it is also possible to encapsulate
more complex actions.



When defining a closure you must worry about the scope of variables. If
a closure includes a variable, is the value of that variable set when
the closure is used, or when it is defined? Most modern languages store
the value when the closure is defined (static scope). In
contrast, early versions of Lisp, for example, were dynamically
scoped
- variables took values that depended on where the closure
was used.



To avoid having variables that count loop iterations functional languages encourage recursion
- where a function calls itself repeatedly with (hopefully) simpler
arguments. The most efficient way of doing this (which also avoids
running out of memory if the routine recurses many times) is tail
recursion
- the routine is called again only at the very end of
the function, when everything has been calculated, allowing the routine
to be restarted without worrying about over-writing variables.



Other features of some functional languages
include currying (a function with some arguments already
supplied), functions that return several values at once, and pattern
matching (to assign values from multiple returns).



Functional languages can be divided into two groups, depending on
whether or not they use lazy evaluation. If a language is
lazy, then functions are not evaluated until they are actually needed
inside an expression, while non-lazy (eager/strict evaluation)
languages evaluate functions as soon as they are passed as arguments.
Laziness leads to some elegant solutions for problems involving
infinite series and seems (to me, at least) more consistent with the
idea of functional programming. However, because the order in which
functions are used is not very clear to the programmer, the speed and
efficiency of programs written in lazy languages can be difficult to
understand.



Without permanent state there is less need for objects in functional languages, but types are still
important - new types can be defined (constructed types) and
are operated on using pattern matching (you might define a
complex number type as having two real numbers, pattern matching lets
you refer to the numbers separately). Haskell (which is the "standard" functional
language in some respects) has a concept of type classes that
allows functions to operate on related types.



Flexible Syntax



Some languages allow operator overloading where functions can
be defined that correspond to operators (e.g. +, -). This allows
operations on different types to be expressed using a natural syntax
(addition of matrices is an obvious example).



In languages like Tcl and Lisp, the distinction between language and data is
very flexible (dynamic). It is easy for the input to the
program to be a program, or a program fragment. In other languages the
division is rigid (static). When language and data are similar
it is often possible to change the syntax of the language quite easily,
while stricter languages only allow extensions in certain pre-defined
ways.



Where code and data are strongly separated it may still be possible (in
strongly typed languages) for code to enquire about the structure of
the program, and even to create further code (Java, Python).



Compilation



A computer's CPU does not process a high level language directly - the
program must be translated to machine code. This can be done
once, as a distinct step before the program is run
(compilation) to produce an executable, or the
translation be done dynamically, when the program is run
(interpretation). It is also common for a program to be
compiled to an intermediate representation (byte code or
p-code) which can be interpreted more efficiently. More
compilation before the program is run implies less overhead and greater
speed later; the compiler can also analyse more of the code and so
perform static optimisations. Some interpreters are
sophisticated enough to analyse the running program and make
dynamic optimisations - these use information not available to
a static compiler, but static compilation still gives the best
performance in most cases.



Some languages must be compiled, others are interpreted. Many offer
both options (it can be useful to develop and test using an
interpreter, then compile for maximum performance once the program is
working, for example). Some languages produce separate programs while
"programming" others means extending the (monolithic) language /
interpreter until it does what you require (Smalltalk, Forth).
This last approach can be flexible enough to allow programs to be
modified with new code while they are still running.



Threads



In a multi-threaded program the same code is "run" more than
once at the "same" time. If there is only a single processor then in
practice the different threads takes turns to execute.



Having several threads running at once can be useful. For example, a
graphical display can remain responsive (using one thread) while the
program is doing some calculations (using another thread). But it can
also introduce problems. For example, two threads may update data at
"the same time". With complex data it is possible for corruption to
occur. Mechanisms are needed to prevent this, but the same mechanisms
can introduce further problems (in my experience with multi-threaded
Java code, thread problems are the main source of run-time errors).



Taking the idea of threads further, it's possible for programs
to be distributed - separate parts of the process running on
different machines, communicating across the network.



Some languages have no explicit support for threads (C, Common Lisp), or
include only basic features (Java). Others have multiple threads as a
key idea (Oz, Occam, Erlang - the
designer of Erlang argues that concurrency
oriented
programming is an important concept, for more
information see the talk via the previous link.).



Error Handling



When an error occurs in a a program, how is it handled? Many languages
implement various forms of exception handling - an error
forces a function to return (and the function from which it is called
to return...) until a special section of code is met that deals with
the error.



This can cause subtle errors with programs that do not have automatic
memory management (see below) - especially in C++.



Data Structures



Some languages include complex structures (lists, tables, etc) within
the core language, others have standard libraries that are separate
from the core language but considered part of the standard language
implementation. Recently, libraries that support Internet applications
have been popular (following Java's success -
Rebol is an extreme example). Many languages also include libraries to
help implement graphical user interfaces (GUI).



Some libraries are provided as closed, read-only packages. others have
source available; often the code can be modified and re-used (for more
information check out open source, FSF, gnu).



When the program is stopped, how are data stored? Does the language
have persistent storage (some kind of database that keeps information a
program is not running)?



In a related vein, how is memory for data structures managed? Memory
used to store a particular piece of data must not be recycled if the
contents are still being used (but leaving the contents alone when they
are not needed can quickly use all the available memory). This may not
be a difficult problem in functional languages,
but in procedural languages the extent (in time) of a piece of data is
not always obvious. Some languages avoid this problem by having the
size of all data items known at run-time (Fortran 77), others provide
routines that automatically manage the memory (garbage collection -
GC
), and the rest leave it to the programmer to explicitly request
and release memory (C, C++).



Development
Environment



What is the development environment like? Is it command-line based or
is there a graphical interface? Is there a builder to create your own
GUI? If so, how does it structure the interface - is it hierarchical or
flat, do you have to modify the generated code? Does the environment
support a particular development methodology?






Learning Languages




Why Learn a new Language?



Although there is some evidence that things are changing, it is still
fair to say that the selection of languages used in software
development is fairly static. So there is little pressure to learn a
new language to keep your job.



But I believe learning a new language can make you a better programmer.



Ignoring the fun involved, and the practical advantages of having more
than one tool available for the next problem, there are two basic
reasons why you might want to learn a new language:




  • By "moving up" (learning Java if you normally
    use C++, for example) you learn lessons that
    transfer directly back to the language you normally use.


  • By "moving across" (learning a language with a very different set of
    core ideas) you can widen your perspective and learn new approaches
    to problems that may seem difficult in you "usual" language.



Moving Up



As an example of the first case, let's look at the arguments for
learning Java if you program in C or C++.



It is very difficult to write a program in Java
without beginning to understand how to use classes and objects - this
is in contrast to C++, where you can continue
using the same style of programming you used with C. So learning Java will
teach you about OOP. Aside from your CV,
understanding the principles behind OOP will
help you become a better programmer.



It is possible to carry back what you have learnt and write C code in an OO manner (of
course, if you have already been doing this, much of OOP seems little more than hype). This usually
means using structures which contain pointers to functions that take
the structure as an argument. If you have met this style, you'll
understand what I mean; if you haven't, you should once you have used
an OO language (Python's syntax is particularly useful in laying
bare the bones of OOP).



Even if you use C++ as it was intended, you can
still learn from Java - a more complete class
hierarchy, extensive libraries, introspection, and platform
independence are all areas of the language that can change your
perspective.



A similar case can be made for learning C++ if
you know C, but you must discipline yourself to do
things the "OOP way". And of course, if you know
only Java you can learn a lot by looking at C (not just understanding, from your errors, why Java
is designed as it is, but also learning more about machine level
details).



Moving Across



Now the second case, "moving across". Looking at programming from a new
angle gives insights that remain useful when you return to your
original viewpoint. Different languages express the same
patterns (algorithms, approaches, solutions) in different
ways: by looking at a pattern with a different emphasis it is possible
to understand the pattern more completely. Sometimes a pattern is much
clearer in one language than another, but once it has been seen in its
simple form the more version can become much clearer. Patterns rely
partly on language features and partly on convention - the balance
shifts between languages and can illuminate the use of apparently
arbitrary conventions.




As a simple example, consider recursion. As a new programmer in C, in my first job, I knew nothing about recursion
(except that the concept existed). In my spare time I was playing with
ML, where it is normal to write recursive
function calls (and difficult to loop in the "usual" - procedural -
way). I understood the arguments against recursion in C and understood why recursion (at least tail
recursion) was more efficient in other languages. At first I found it
difficult to write in ML, but slowly, with
practice, I learnt to recognise where recursion naturally worked. Not
long afterwards I had a problem at work, writing in C, that was difficult to solve neatly. My first
attempt was ugly and contained a bug. But I recognised that it would be
much simpler with recursion. The recursive code was clear, as simple as
possible, and worked perfectly.



A slightly more complex example might be covariant and contravariant OO languages. When I have the time, I'll be trying
out Eiffel because as I wrote this, and tried
to understand the difference (see what I wrote here), I realised that it changed a whole pile of
assumptions I had unconsciously made about OOP.



As a final example, look at the emphasis in functional languages on moving programs closer to
specifications. Learning to use such a language will raise questions
about the development process.



How to Learn a New
Language



How do you learn a new language? The fastest way is when you are forced
to do so (I learnt the only other natural language I know apart from
English - Spanish - when i had to live with my Chilean mother-in-law
for three months). But if you're lucky enough to be learning by choice,
you are probably doing it in your spare time and you won't do that
unless you are enjoying yourself - so choose an interesting project.



Choosing what you are going to write in your new language is more
important than choosing the language. Choose the language to suit the
project or, better, choose both together. For example, if you want to
write something that will look good then don't choose a language with
no support for graphics.



Learn a little about the language before you start and try and find a
solution that will play to the language's new features. If you are
using OOP for the first time, for example, try
and think how your project can be split into objects (I can remember
doing this and wondering how all these objects would actually turn into
a working program; where was the mysterious transition into running
code? - in retrospect, it just, well, happens...). If you are looking
at functional programming, maybe a numerical
project would be a good start (I chose cryptography) (this suggestion
does not imply that functional languages are
only useful for numerical code, just that most textbooks seem to
feature numerical examples - in my limited experience - making it
easier to start in that direction).



At the same time, be honest with yourself. Don't be too ambitious -
don't pick too difficult a project and (maybe) don't pick too exotic a
language. The second point is debatable. With any language you will
learn something new: it doesn't have to be a huge intellectual leap
into the unknown. You are going to be more productive in a language
that has some familiar ideas, and you can lean on that part of the
language to get going. On the other hand, if you enjoy new ideas, maybe
you will be happier with something completely different.



It should be clear now that i don't agree with a poster to
comp.lang.Lisp who claimed good programmers can learn a new language in
a week. Of course, it is possible to understand the basic concepts -
when i tried ML (see the example above) i quickly understood how to
write recursive routines, but it took more than a week of practice
before i could look at a problem and feel the solution.



Support is also important. If you intend to post questions to Usenet,
is there an appropriate newsgroup? And is it tolerant of newbie
questions? Personally, i like books - the best impetus for me is
finding a good book on computing that uses a particular language in the
examples (Abelson and Sussman, or Norvig, are two clear examples).



A note about asking for information on newsgroups: people seem to vary
widely in how precisely they talk about languages. At one end of the
spectrum there are people who tend to rely on a "subconscious" (or at
least "sub-language") intuition and happily mis-use terminology to "get
the idea across". At the other end are people who are very precise.
Both, no doubt, will give conflicting advice on how to learn and,
sometimes, apparently conflicting answers to questions. You have to
learn to recognise different styles and read them in the context of the
poster.



I am at the "sub-language" / relaxed terminology end of this spectrum,
so don't trust everything you read here (I wrote it partly to find out
just what I knew, and to make myself learn more of the terminology).
From my writing style and the introduction I hope that it is clear that
my aim is to convey general ideas, not precise details (I think this is
useful, but it probably annoys the hell out of language-lawyer pedants
:-).



Finally, don't be afraid to change direction. I'v

Getting Started in Programming.bku.yang摘引

Getting Started in Programming

Questions that is often asked in the various programming news groups are variants of "What language should I learn?"

It is a good question. There is an awful lot of languages out there and it is hard to get an overview of the possibilities without a lot of work.

After seeing the question three times in the same week I decided to write this web page to try to give my answer to it. Since then I have occationally added to and revised it.

I would like to emphazise that these are my opinions and nothing more. Others are bound to disagree.

I'll name a lot of different languages below. Exactly which languages I have mentioned in the various sections is somewhat random, if I left one out it is probably because I haven't heard about it rather than any negative opinion about it.

The hyperlinks from each language name are of variable quality. I have stolen most of them from this page.

First things first: English

The very first language you should learn is English. I write this because often people ask for good books in their own native language and are unwilling to accept that the answer very often is "There aren't any."

At least in Norwegian, that is. I don't know the situation for Spanish, Russian or German, but in the lesser used languages the market for good computer books simply isn't there.

Your English doesn't have to be excellent, it just have to be good enough that you can read an English computer book without too many problems.


Reading documentation

The most useful skill you can learn is the ability to read computer documentation. As a programmer you will need to know a lot more than you can easily remember. This doesn't matter if you can find the information you need, when you need it. And quickly.

The most useful part of any technical book is its index. If the book lacks an index, recycle it. It is worth more as recycled paper than as a book.

For online documentation this can either be an actual index (most useful) or some sort of search mechanism (not so useful, but usable).

When you have a specific question you wonder about, turn to the index. The most interesting entries are often the last and the first ones for any given word, in that order. The last entry is often a summary and the first entry is often an introduction. (This rule has a lot of exceptions, of course)

The table of contents can be useful too.

Other than that, you simply need experience. It takes some time to learn how to quickly pinpoint the exact information you are looking for. I have no advice beyond: Practice.

The same skills can also be used for reading computer programs. There will seldom be an index available, but you usually have some way of searching the program text.


Finding a good book

There are a lot of computer books out there. Some are good, some are bad. If all you have is a bad book, it can seriously slow you down. You can also miss important ideas that better books explain to you.

A few general rules to help you:


  • Unless you have a lot of money, start at the library. You might have to go through some books before you find a good one.
  • Visit academic book stores and libraries rather than general ones. The books there are usually much better.
  • Avoid books with titles containing the words "Idiot", "Dummies" or "in XX days". These books are for dummies. Seriously.
  • Judge a book by its index. Both because you will be using the index a lot and because a good index shows that this book is written by somebody who knows what they are doing.
  • As far as I know, O'Reilly and Associates have only published good books. (This was true when I first wrote this page... but things have changed. Their quality control seems to have slipped a bit)

Variation!

The question often takes the form "Which one language should I learn?". Or worse: "Should I learn X or Y?". This is starting in the wrong end. What you should learn aren't languages, but ideas and new ways to think.

If you learn just one language you will have blind spots and be limited in the ways you approach new problems.

By learning more languages you will be able to find new ways to solve your problems.

This means that knowing Prolog, Forth and Lisp will make you a better C programmer. This sounds weird, but it is true.


Never mind the details.

Some languages you will learn because you need them, to program something big in. These languages you will need to learn properly, with much detailed knowledge. However, most of that knowledge can be picked up as you go, by reading documentation.

Other languages you will learn because they look interesting, or somebody have recommended them. For these languages learning details is totally unimportant. The main thing is to learn the ideas of the language.

When you face a new language, try to find out what makes that language unique and what the strong points of that language are. Never mind its weak points, you will find them soon enough if you need to. The strong points are easier to overlook. On the other hand, books are often eager to point them out to you.


I said variation!

A lot of languages are very similar. If you have learned BASIC, Pascal and FORTRAN you haven't really learned a lot of variation. If you then learn C, C++ and Java, you will have learned, total, about two languages worth of ideas or so.

The six languages mentioned are very similar in their basic ideas, but this may not be obvious if they are the only ones you know. As I said: Blind spots. (Those languages look rather different from eachother)

So, which languages should you learn? Well, this is where the experts start arguing...

However, a better question is what ideas should you learn.


In general

There is an old saying that "A Real Programmer can program FORTRAN in any language." This means that you can use imperative techniques in almost any language. However, this is seldom wise. (FORTRAN is the archetypcial imperative language)

The same goes for most of the the ideas mentioned below. Most of them are about the way you think while programming rather than the languages themselves. On the other hand, a language can be more or less suited for that way of thinking. It is often, but not always, a good idea to use a style of programming suited for the language used. (Or the other way around, of course)


Imperative programming

The languages mentioned in the previous two paragraphs are geared towards the idea of "imperative programming" where you give the computer commands and you have to decide almost everything. Programs look like "First do this. Then do that. Store the result of that over there. " and so on.

These languages are the inspiration for proverbs like "The computer does exactly what you ask it to do. Unfortunately."


Object orientation (OO)

What is "object orientation"? What does it mean? I don't really know... The words has been used by so many to mean so many different things that they have almost lost any meaning! (Kent Pitman writes on this). Java and C++, as well as many others, claim to be OO. SIMULA and Smalltalk were the original object oriented languages and they still have their devoted followers. There are also many others who use this catchphrase, look around.


Functional programming

Another important idea is "functional programming" which means two things. The first is that you call a lot of functions to do things that you would do in other ways in other languages. However, this is not the main point. The main point is that you can use functions as values, i.e. storing them in variables and passing them around as function parameters and return values. (If that didn't make sense to you, it means you have something to learn here)

The first functional language was Lisp , and various Lisp variants still form the core of the family of functional languages. Look for some implementation of Common Lisp. Haskell, Erlang and ML are other popular functional languages.


Declarative programming

The remaining main trend in computer languages is "declarative programming". This means that you tell the computer things like "Harald is a parent of Haakon. Olav is a parent of Harald. A grandparent is the parent of a parent." The system can then answer questions like "Who is the grandparent of Haakon?". (The system does not understand plain English like this. You have to be much more careful in how you phrase things to a computer) Prolog is the main language in this family. This type of programming isn't used all that much, but is worth learning for its mindbendingness.


Another way of seeing it

The difference between imperative, object oriented, functional and declarative programming can be best seen in how you divide the program into parts:

  • Imperative: Each part performs a task
  • Object oriented: Each part describes an object
  • Functional: Each part calculates a function
  • Declarative: Each part describes a relation
These alternatives do not exclude each other.

Programming by contract

Somewhat independent of the above, "programming by contract" is a way of designing programs. Each part of a program has a "contract" which specifies how it should cooperate with the rest of the program.

This documentation is usually only written in a form that humans understand, something like "When given a positive real number, this function calculates its square root". Note that this contract contains two parts, the input spesification (postive real number) and the output specification (calculates the square root).

The idea behind "programming by contract" is that one should make as much of this information available to the computer as possible. This means that the system itself can catch a lot of the simple errors programmers make. The main laguage using this concept is Eiffel.


Databases

Databases are also extremely common and are something you should know a bit about. Most databases these days understand a language called SQL, which you should have a look at. However, SQL is not a programming language as such and you need something more powerful to actually program a database system. Look for languages called "something SQL" or "SQL something".


Event-driven programming

Another semi-important idea is "event-driven programming" which is mostly used in GUIs (Graphical User Interfaces). The basic idea is that instead of saying 'first we do this, than we do that' you say 'if the user clicks that button, this happens. If the user clicks the other button, that happens.' While programming, you don't know which order these things happen, so you have to carefully consider all possibilites. This type of programming can be done in almost any language, but Netscapes JavaScript and Microsofts JScript are examples of languages explicitely made for this.


Assembly language

And then there are the assembly languages. Some people say that you should know an assembly language or two to get a better feeling for what the machine can and cannot do. Some people say that this is totally unnecessary. Personally, I tend to agree with the first opinion, from the principal point of view that more knowledge is always a good thing. However, learning assembly language is tiresome and might not be worth the effort, I don't know. If you decide to do this, keep "Never mind the details" firmly in mind.

A good way to start learning assembly is asking a compiler for some high level language to show you the assembly language it generates rather than making machine code directly. (Unfortunately, not all compilers can do this) Do this for very small programs at first. This will not teach you to program in assembly, but will give you an idea of what assembly is and what the machine can do.


Algorithms and Data Structures

Most algorithms and data structures are fairly independent of which language you use. Their description are often left out in language-specific books.

You should read a good book on Algorithms and Data Structures. Good books are often called just "Algorithms and Data Structures" or something similar. As always, the details doesn't matter much at first. Remember what algorithms and datastructures the book shows you, and what their main strong and weak spots are. When you need details, look them up.


Readable Programs

Learn to write readable programs. You may have no problem understanding your program today, but next month it can be almost gibberish if you aren't careful. If somebody else tries to understand your program it gets even harder. Important keywords here are: Layout, good names, comments and documentation.

Remember: Code is written once and read a thousand times. A bit of care while you write can save you a whole lot of grief down the road.

Good layout means that you should be able to see the structure of the program at a glance.

Good names for variables, functions and so on means that the name should give the reader a good idea of the varable/function/whatever is used for.

Comments are for all the stuff that doesn't fit the above. It is important that the comments shouldn't tell you what is obvious from the code, but what is not obvious.

Documentation is all of the above, but rewritten in a way that is easier for humans to read, rather than computers. There will be a lot of duplication between comments and documentation.


Computer Science

Some people think that when they have learned to program in a language or two, they know 'Computer Science'. This is not so, CS is a lot lot more than just programming.

CS is a branch of mathematics, and you need a solid mathematical background before learning it. Picking this up on your own is not easy. If you want to learn CS, get thee to a university.


Conclusions

The important thing isn't where you start, it is that you never stop learning.

Don't learn languages, learn ideas.


See also

Various stuff(I've stolen a lot from there)
Dictionary of Computing
Web searches can find the most amazing stuff. Sometimes even what you were looking for.
Some of Kent Pitmans musing on various subjects.



stig@pvv.ntnu.no
Last modified: Thu Nov 6 13:00:45 CET 2003

Progamming

An Introduction to Programming Languages
http://www.acooke.org/andrew/writing/lang.html

Getting Started in Programming
http://www.pvv.ntnu.no/~stig/where-to-start.html

Sunday, April 16, 2006

MATLAB SITES

中文MATLAB教程

Saturday, April 15, 2006

PHP SITES

















http://blog.edu.cn/http://blog.edu.cn/PHP: Hypertext Preprocessor http://www.php.net/
PHP is a server-side HTML embedded scripting language. It provides web developers with a full suite of tools for building dynamic websites: native APIs to Apache and other web servers; easy access to MySQL, Sybase, Oracle, and other databases; IMAP; LDAP; HTTP headers and cookies. This site is the official home of PHP4.
 http://blog.edu.cn/http://blog.edu.cn/Zend http://www.zend.com/
A bottom-up rewrite of the PHP scripting engine. It features a modular architecture, vastly improved performance, and greater scalability.
 http://blog.edu.cn/http://blog.edu.cn/Quality Assurance Team http://qa.php.net/
Voulonteer coders dedicated to providing coders with quality assurance.
 http://blog.edu.cn/http://blog.edu.cn/International PHP Magazine http://www.php-mag.net/
Web-based magazine for Web professionals focused on PHP based development. News, online articles, book reviews, forum.
 http://blog.edu.cn/http://blog.edu.cn/Codewalkers http://codewalkers.com/
A community site dedicated to PHP and SQL. Includes user submitted code, tutorials and forums.

















 http://blog.edu.cn/http://blog.edu.cn/PHP Freaks http://www.phpfreaks.com/
A community designed to assist developers with PHP and MySQL related information. Includes tips, tutorials, forums, articles, code examples and manuals.
 http://blog.edu.cn/http://blog.edu.cn/PHP Magazine Blogs http://phpmagazine.net/
A community of PHP authors. You can start own PHP blog.
 http://blog.edu.cn/http://blog.edu.cn/PHP Everywhere http://phplens.com/phpeverywhere/
John Lim's weblog with comments and reviews. Links to his longer articles and manuals.
 http://blog.edu.cn/http://blog.edu.cn/PHPMac.com http://www.phpmac.com/
Dedicated to PHP programmers that use the Mac OS, in particular Apple's OS X unix system. Tutotials, articles and support.
 http://blog.edu.cn/http://blog.edu.cn/PHPit http://www.phpit.net/
PHP and MySQL articles, tutorials and codesnippets. It also has database with commonly asked questions.











 http://blog.edu.cn/http://blog.edu.cn/PHP Club http://www.phpclub.net/
A programmer's group united by a desire to develop PHP technologies in the Internet. News, articles, applications and FAQ.
 http://blog.edu.cn/http://blog.edu.cn/ThePHPGuy http://www.thephpguy.com/
PHP, MySQL and Apache articles, tutorials, guides and a free help forum. Free PHP scripts and programming tips and tricks.
 CodingTheWeb: PHP News http://www.codingtheweb.com/projects/newslog/portal/1_1.htm
PHP development news, tutorials, and technical articles. Available as XML and RSS feeds.

Monday, April 10, 2006

亦彩软件下载

亦彩软件下载 http://download.cqu.edu.cn


教育网上速度可以。

Monday, April 3, 2006

学历相关常识介绍(学位与学历的联系与区别...)

学历相关常识介绍 
 
  我国目前国民教育系列的高等教育学历分专科、本科、硕士研究生和博士研究生四个层次;从学历系列上讲,主要包括专科、本科、第二学士学位班、研究生班(目前已停办)、硕士研究生和博士研究生六个方面。此外,还包括1970年至1976年普通高校举办的大学普通班。高等教育学历文凭主要有三种,即:普通高等教育毕业(结业)证书、成人高等教育毕业(结业)证书、高等教育自学考试毕业(结业)证书。


  以上学历证书由经国家教育行政主管部门批准备案的独立设立的普通高等学校(含设在成人高等学校、军事院校中的普通班,提供现代远程教育的机构)、成人高等学校(即广播电视大学、职工高等学校、农民高等学校、管理干部学院、教育学院、独立设置的函授学院)、民办学历高校发给其所举办的高等学历教育的毕业生,以及由社会力量办学单位发给高等教育自学考试毕业生。


  第二专业学历教育


  第二专业专科学历教育是为适应经济和社会发展对复合型人才的需求,满足从业人员拓宽知识、专业领域的要求而举办的成人继续教育。第二专业专科学历教育招收具有国民教育系列大学专科以上学历的从业人员,其工龄、年龄不予限制。报考第二专科学历教育的考生,报名时须向报考学校交验国民教育系列大学专科以上毕业证书原件或复印件,由省级招生机构审核认定。学生毕业时颁发国家承认的成人高等教育专科毕业证书。


  如何取得高等教育学历证书


  [1] 参加全国普通高等学校招生统一入学考试,经省一级招生部门统一组织,由学生所报考的普通高校录取后正式取得学籍,进行全日制脱产学习。


  [2] 参加全国成人高等学校招生统一入学考试,经省一级招生部门统一组织,由学员所报考的成人高校或普通高校成人教育学院录取后正式取得学籍。主要学习方式:一是进入高校全日制脱产学习;二是进入高校以业余面授方式学习;三是进入普通高校设立的函授站以函授形式业余学习。


  [3] 参加省级教育行政部门统一组织的高等职业教育对口招生统一入学考试,经省招生部门统一组织,由对口招生学校录取后正式取得学籍,进行全日制脱产学习。


  [4] 参加高等教育自学考试,可以通过参加社会力量助学单位组织的辅导,定期参加自学考试管理部门统一组织的课程考试。


  [5] 参加省级教育行政部门组织的学历文凭入学考试(或由省级教育行政部门直接在当年普通高考录取分数线下确定学历文凭考试学校的录取线)并被实施学历文凭考试学校录取,取得正式学籍,进行全日制脱产学习。


  [6] 参加普通高等学校以现代远程教育形式举办的高等学历教育班,入学时只参加由招生学校组织的测试,经学校录取后,学员在学校设立的教学中心组班学习。


  高等教育学历文凭考试


  高等教育学历文凭考试是国家对尚不具备颁发学历文凭资格的民办高校的学生组织的学历认定考试,是教育考试制度的组成部分,也是以学校办学和国家考试相结合、宽进严出、教考分离为特点的全日制高等学校教育。取得高等教育学历文凭考试试点资格的学校,可根据省级教育行政部门确定的招生专业和招生计划,在普通高考本专科录取线以下确定相应的录取分数线,或本校自行组织入学考试。取得学历文凭考试资格的学生,修完教学计划规定的全部课程(除 30%的课程由所在学校自行命题组织考试外,其余70%的课程要参加高等教育自学考试,包括全国统考课、省统考课)和实践性教学环节,成绩合格,并经思想品德鉴定合格,由省考办核发国家承认的高等教育自学考试专科毕业证书,毕业证书由全国自考办统一印刷,在证书内芯上加盖试点学校印章。


  普通高等教育学历证书管理


  普通高等教育学历证书分为毕业证书、结业证书、肄业证书三种。学历证书的颁发对象为:研究生、本科生、专科生、第二学士学位班学生,列入普通高等教育招生计划的电视大学、函授大学、夜大学普通专科班学生。


  1993年以前,全国各地在普通高等教育学历证书管理方面的做法不尽一致。有的省、市、自治区和部委对其所属高校的学历证书统一印制或管理,有的则由高校自行印制或管理。由于没有对有关工作的统一要求,加之存在一些管理方面的漏洞,出现了一些办学单位违反国家政策滥办学和乱发文凭的事件,影响了高等教育的办学质量和社会声誉。另一方面,在客观上给不法分子伪造贩卖普通高等教育学历证书以可乘之机。


  从1993年起,普通高等教育学历证书实行国家、省(自治区、直辖市)或国务院有关部门、学校三级管理。教育部(原国家教委)对地区、部门按招生计划及实际毕业(结业)人数进行总量控制,统一印制普通高等学校毕业和结业证书或证书的内芯;制定有关学历证书的管理规定和实施办法;对学生的毕业(结业)资格审查和证书的办法工作进行检查、监督。2000年,教育部开始建立普通高等教育学历证书电子注册制度,此项改革将使教育部不再统一印制高等教育学历证书内芯,改由高等学校自行印制,但必须进行电子注册,并供网上查询。2000年在北京、天津、辽宁、湖北、重庆五省市试点,2001年在全国实行各类高等教育学历证书电子注册制度。


  学历的颁发与认证


  经国家教育主管部门批准具有举办学历教育资格的普通高等学校(含培养研究生的科研单位)、成人高等学校、民办学历学校所颁发的学历证书,国家予以承认。另外,通过自学考试、由国务院自学考试委员会授权各省(自治区、直辖市)自学考试委员会颁发的自学考试毕业证书,经国家教育主管部门批准在党校、成人高校、军事院校设立的全日制普通班中就读的学生所取得的毕业证书,学历文凭考试学校颁发的毕业证书,普通高等学校以远程教育形式举办的高等学历教育所颁发的毕业证书,以及符合《中国人民解放军院校学历证书管理暂行规定》所颁发的学历证书,国家同样予以承认。教育部决定从2001年开始,我国高等教育学历证书的管理实行电子注册制度,并委托全国高校学生信息咨询与就业指导中心负责学历电子注册审核、备案的技术性、事务性和网上查询、认证服务工作,2001年以后的学历证书可以在中心注册的中国高等教育学生信息网(www.chsi.com.cn)上查询,此外中心还提供学历证书认证服务,经认证的学历证书可在中心注册的网上查询。


  什么是学位


  学位是标志被授予者的受教育程度和学术水平达到规定标准的学术称号。我国学位分学士、硕士、博士三级;“博士后”不是学位,而是指获准进入博士后科研流动站从事科学研究工作的博士学位获得者。


  学士学位,由国务院授权高等学校授予,硕士学位、博士学位由国务院授予的高等学校和科研机构授予。高等学校本科毕业生,成绩优良,达到规定的学术水平者,授予学士学位;高等学校和科研机构的研究生,或具有研究生毕业同等学力的人员,通过硕士(博士)学位的课程考试和论文答辩,成绩合格,达到规定的学术水平者,授予硕士(博士)学位。授予学位的高等学校和科学研究机构,在学位评定委员会做出授予学位的决议后,发给学位获得者相应的学位证书。


  对于国内外卓越的学者或著名的社会活动家,经学位授予单位提名,国务院学位委员会批准,可以授予名誉博士学位。


  学位与学历的联系与区别


  学位不等同于学历,获得学位证书而未取得学历证书者仍为原学历。取得硕士学位或博士学位证书的,却不一定能够获得硕士研究生或博士研究生毕业证书;而取得大学本科毕业证书的,却不一定能够获得学士学位证书。现在经常出现将学位与学历相混淆的现象,如有的人学历为本科毕业,以后通过在职人员学位申请取得了博士学位,这时,学历仍为本科,而不能称之为取得 "博士学历"。


  在职申请学位不是学历教育。申请人在获得学位后,只表明其在学术上已达到硕士学位的学术水平,具有硕士学位毕业研究生的同等学力(学习能力的"力"),不涉及学历。因此申请人的学历并没有改变,也不能获得硕士研究生毕业证书。


  在职研究生则是国家计划内,以在职人员身份,部分时间在职工作,部分时间在校学习的研究生教育的一种类型。在职研究生在报名、考试要求及录取办法方面与脱产研究生相同。是经过学校录取的正式研究生,可获得研究生毕业的学历。