Tên Công ty; Công ty Cổ phần Giải pháp Công nghệ Moss [Tech Moss] Nơi làm việc: Vạn Phúc, Hà Đông Nhân viên triển khai phần mềm [SL: 05] Mã vị trí: Trienkhai
[Mức lương: 6 – 15 triệu VNĐ, tùy vào năng lực, kinh nghiệm]
– Tìm hiểu và sử dụng được các tính năng của Phần mềm Quản lý Nhà thuốc, Phần mềm Quản lý Bệnh viện, phòng khám – Hướng dẫn khách hàng, người dùng sử dụng, thao tác trên Phần mềm; các tính năng ưu việt – Ghi nhận, tổng hợp các ý kiến người sử dụng về phần mềm, hỗ trợ khách hàng Hình thức làm việc: Toàn thời gian
Quyền lợi được hưởng:
– Hưởng đầy đủ lương, trợ cấp theo quy định – Có chế độ thưởng nếu đảm bảo tốt công việc – Tham gia đào tạo các kỹ năng giao tiếp, thuyết trình để triển khai dự án CNTT – Tham gia các hoạt động, team-building của công ty Yêu cầu công việc:
– Nhanh nhẹn, hoạt bát, tiếp cận nhanh với các sản phẩm công nghệ – Sử dụng Tin học văn phòng thành thạo – Có phương tiện di chuyển Developer phát triển phần mềm, app [SL: 05] Mã vị trí: Developer
[Mức lương: 8 – 25 triệu VNĐ, tùy vào năng lực, kinh nghiệm, sẽ trao đổi khi phỏng vấn]
– Xây dựng, phát triển phần mềm giải pháp Y tế – Đề xuất ý tưởng với lãnh đạo công ty Quyền lợi được hưởng:
– Môi trường làm việc năng động, hiện đại, tôn trọng cá nhân; – Được đào tạo để nâng cao năng lực và nghiệp vụ; Có cơ hội thăng tiến; – Được hưởng đầy đủ chế độ lao động, BHXH, BHYT theo Quy định của Nhà nước. Yêu cầu công việc:
– Tốt nghiệp Đại học chuyên ngành Công nghệ thông tin, Điện tử – Viễn thông – Có kinh nghiệm trong các công nghệ NET, API, MVC – Kỹ năng phát triển web: HTML5/CSS3, HTML/XHTML/XML, CSS, Bootstrap, Javascript, jQuery, NodeJS – Thành thạo một trong các hệ quản trị dữ liệu: SQL Sever, Oracle, MySQL. Ưu tiên ứng viên:
– Có kỹ năng thuyết trình, làm việc nhóm, tư duy logic tốt; – Có kinh nghiệm phát triển phần mềm đa nền tảng, đặc biệt là các phần mềm y tế; – Có kinh nghiệm thiết kế giao diện là một lợi thế
Tester – Nhân viên kiểm thử Mã vị trí: Tester
[Mức lương: 8 – 15 triệu đồng]
Số lượng cần tuyển: 03
- Vị trí làm việc: Nhân viên Phòng Nghiệp vụ và Quản trị dự án
- Địa điểm làm việc: Vạn Phúc – Hà Đông – Hà Nội
- Thời gian làm việc: Giờ hành chính, thứ 2 –thứ 6 hàng tuần [2 ngày thứ 7 trong tháng]
*** Mô tả công việc:** – Đọc hiểu các tài liệu đặc tả hệ thống, yêu cầu nghiệp vụ, tài liệu thiết kế liên quan. – Xây dựng kịch bản kiểm thử [Testcase]. – Thực hiện Test sản phẩm của công ty. – Tham gia lập các bộ tài liệu test: Quy trình test, Testplan, Test Point. – Nghiên cứu và cập nhật các công cụ test và kiến thức mới hỗ trợ cho công việc. – Đề xuất cải tiến quy trình test. – Thực hiện tốt các công việc khác khi được giao. *** Yêu Cầu Công Việc:** – Có ít nhất 1 năm kinh nghiệm làm việc tại vị trí tương đương. – Tốt nghiệp Đại học ngành CNTT, Toán tin, Điện tử viễn thông. – Sử dụng thành thạo các công cụ test và quản lý lỗi. – Hiểu biết về quy trình Test, chiến lược và kỹ thuật test phần mềm… lập tài liệu test tốt. – Chủ động, sáng tạo, nhiệt tình, trách nhiệm trong công việc, có tư duy logic tốt. – Cẩn thận, tỉ mỉ, cần cù, nhanh nhẹn, sức khỏe tốt, có khả năng làm việc độc lập hoặc nhóm với cường độ cao. – Kỹ năng giao tiếp tốt, có khả năng quản lý thời gian.
- Ưu tiên:
– Các ứng viên đã làm việc theo quy trình phần mềm, có hiểu biết về hệ thống kiểm soát chất lượng phần mềm, QA, QC. – Các ứng viên có kinh nghiệm test ứng dụng trên Mobile, web. – Có kỹ năng đọc/viết tài liệu kỹ thuật bằng tiếng Anh.
Hạn nộp: 07/01/2020 đến 30/02/2020 NỘP HỒ SƠ TẠI: – Nộp qua email: techmosscorp@gmail.com. Tiêu đề mail đặt theo cú pháp: Vị trí ứng tuyển_Tên Ứng viên [Ví vụ: Developer_Nguyễn Văn A]
– Hoặc inbox qua các kênh: Facebook [TECH MOSS: //www.facebook.com/techmoss.net] – Trực tiếp : Tòa nhà SevenDays. Địa chỉ: LK46A No 6B Khu đô thị mới, phường Vạn Phúc, quận Hà Đông, Hà Nội
- Type: Enhancement
- Component: specification
- Sub-Component: language
- Affected Version: 1.2.0,1.3.1,1.4.2,5.0
- Priority: P5
- Status: Closed
- Resolution: Won't Fix
- OS: linux,solaris_8,windows_95,windows_xp linux,solaris_8,windows_95,windows_xp
- CPU: x86,sparc
- Submitted: 1999-02-12
- Updated: 2005-10-14
- Resolved: 2005-03-19
Name: igT44549 Date: 02/11/99 I think Java would be a much safer language if it would support const parameters like C++. For instance: class Example { void func1[MyObject const myObject] {
myObject.const_methods_only[];
}
}
If a non-const method were called, the compiler would flag
it as an error.
Right now it is impossible to know if a method you call
might modify the class you pass it. This would be something
that the compiler can find easily, but is extremely difficult
for a programmer to know until after the code has been found
defective by a customer.
I think adding const to the language would greatly improve
the Java language in terms of how bug free Java programs
would be. You already did a great job of elimating memory
bugs, why not take it one step farther and help eliminate
other bugs by supporting const parameters [and methods].
[Review ID: 52919]Name: jl125535 Date: 01/04/2002 FULL PRODUCT VERSION : java version "1.3.1" Java[TM] 2 Runtime Environment, Standard Edition [build 1.3.1-b24] Java HotSpot[TM] Client VM [build 1.3.1-b24, mixed mode] FULL OPERATING SYSTEM VERSION : Windows 2000 5.00.2195 Service Pack 2 ADDITIONAL OPERATING SYSTEMS : [All others] A DESCRIPTION OF THE PROBLEM : Related bugs: 4211070, 4093718, 4069541. A COMPREHENSIVE THEORY OF ADDING 'CONST' TO JAVA [This document is also available at .] CONCEPTS A reference variable or constant declared as 'final' has a value that is immutable and cannot be modified to refer to any other object than the one it was initialized to refer to. Thus the 'final' specifier applies to the value of the variable itself, and not to the object referenced by the variable. A reference variable or constant declared as 'const' refers to an immutable object that cannot be modified. The reference variable itself can be modified [if it is not declared 'final']. Thus the 'const' specifier applies to the value of the object referenced by the variable. An object is modified whenever any of its accessible member variables are the subject of an assigment [or compound assignment] or increment/decrement operator. An object is also considered modified whenever a call is made to any of its member methods that are not declared 'const' [see below]. CLASS VARIABLES Only reference [non-primitive] types can have the 'const' specifier applied to them. Primitive types that need to be declared 'const' should be declared 'final' instead. A member variable declared 'const' and declared with a reference type [i.e., any class type extending 'Object' or any interface type], or declared as an array of any type, refers to an immutable object whose value cannot be modified. The reference variable itself can be modified, provided that it is not declared 'final'. The following code fragment illustrates these rules:
class Foo
{
int max = 100;
final int LENGTH = 80;
const int GREAT = 15; // Error
final const int LEAST = 2; // Error
Bar b = new Bar[17];
final Bar bf = new Bar[23];
const Bar bc = new Bar[55];
final const Bar bfc = new Bar[79];
}
The member variable 'max' is modifiable.
The member constant 'LENGTH' is not modifiable [because
it is 'final'].
The member variable 'b' is modifiable, and refers to an
object that is modifiable.
The member constant 'bf' is not modifiable [because it
is 'final'], but the object to which it refers is
modifiable.
The member constant 'bc' is modifiable, but the object
to which it refers is not modifiable [because it is
'const'].
The member constant 'bf' is not modifiable [because it
is 'final'], and the object to which it refers is not
modifiable [because it is 'const'].
ASSIGMENT EXPRESSIONS
Expressions of reference type, either const or
non-const, can be freely assigned to const variables of
compatible reference types, and can be freely passed to
methods as const arguments of compatible reference
types.
Expressions of const reference type can only be
assigned to const variables, or passed as const
arguments to methods, of compatible reference types.
An expression of const reference type cannot be cast to
a compatible non-const [see the Cast Expressions
section below].
Consider the following code fragment:class Foosball
extends Bar
{
const Bar bc;
Foosball fb;
const Foosball fc;
void enconst1[Foosball f]
{
bc = f; // Okay, implicit cast
fb = f; // Okay
fc = f; // Okay, implicit cast
}
void enconst2[const Foosball f]
{
bc = f; // Okay, implicit cast
fb = f; // Error, f is const
fc = f; // Okay
}
}
INTERFACE CONSTANTS
Since all member variables of interfaces must be
declared 'final', all such member variables are
actually constants. In all other respects, the rules
for const member constants are the same as for const
class member variables.
Consider the following code fragment:interface Baz
{
static final Bar bf = new Bar[1];
static const Bar bc = new Bar[2];
static final const Bar bfc = new Bar[3];
}
Member methods of classes that implement interface
'Baz' cannot modify any of the three constants 'bf',
'bc', or 'bfc' [because they are final]. Such methods
are allowed to modify the Bar object referenced by
'bf', but cannot modify the objects referenced by 'bc'
or 'bfc' [because they are const].
CLASS METHODS
Static member methods declared 'const' cannot modify
any static class variables of their parent class. They
also cannot modify any objects referenced by any static
class reference variables of their parent class.
Non-static member methods declared 'const' may not
modify any member variables [static or not] of their
parent class object ['this']. They also cannot modify
any objects referenced by any class reference variables
[static or not] of their parent class.
A method declared 'const' declares that it cannot
modify any member variables of its class, nor any
objects referenced by those variables. Conversely, a
method that is not declared 'const' declares that it
may modify member variables of its class or objects
referenced by them [and should be assumed to do so,
whether it actually does or not].
The following code fragment illustrates these rules
[it is assumed that 'Bar.peek[]' is a const method and
'Bar.poke[]' is not]:class Foomy
{
static Bar bs = new Bar[15];
Bar b = new Bar[34];
const Bar b2 = new Bar[53];
void frob[] // Not const
{
bs = new Bar[48]; // Okay
b = new Bar[81]; // Okay
frotz[]; // Okay
b.poke[13]; // Okay
b.peek[]; // Okay
b2.poke[13]; // Error
b2.peek[]; // Okay
}
void fraz[] const // Is const
{
bs = new Bar[48]; // Error
b = new Bar[81]; // Error
frotz[]; // Error
b.poke[13]; // Error
b.peek[]; // Okay
b2.poke[13]; // Error
b2.peek[]; // Okay
}
void frotz[] // Not const
{ ... }
}
Member method 'frob[]' is not declared 'const', so it
can modify any non-const member variables of class
'Foomy'. It cannot modify any const member variables,
though, such as 'b2'.
Member method 'fraz[]' is declared 'const', so it
cannot modify any member variables of class 'Foomy'.
It also cannot indirectly modify any member of the
class by calling non-const member methods, such as
'frotz[]'. It also cannot indirectly modify any member
by calling non-const methods on those members, such as
'b.poke[]' [which is not declared 'const' in this
example].
Member method 'frotz[]' is not declared 'const', so it
must be assumed to modify member variables of class
'Foomy'.
A non-static member method of a class that extends
another class or implements an interface which
overrides a method of the base class or implements a
method of the interface must be declared with a
"const-ness" that is at least as restrictive as the
method it overrides. In other words, if a method in a
base class is declared 'const', then all subclass
methods that override that method must also be declared
'const'; on the other hand, an overriding method may be
declared 'const' even if the method it overrides is not
declared 'const'. [In this respect, 'const' specifiers
are similar to 'throws' clauses.]
The following code fragment illustrates these rules:class Foomier
extends Foomy
{
void frob[] const // Added const
{ ... }
void fraz[] const // Must be const
{ ... }
}
class Foomiest
extends Foomy
{
void fraz[] // Error, Must be const
{ ... }
}
LOCAL VARIABLES
Variables local to a method body may be declared
'const', in which case the objects they refer to cannot
be modified. The reference variables themselves can be
modified provided they are not declared 'final'.
Consider the following code fragment:void f[]
{
Object o = new Object[];
final Object fo = new Object[];
const Object co = new Object[];
final const Object fco = new Object[];
...
}
The object referenced by 'o' can be modified, and
variable 'o' can be modified to refer to a different
object.
The object referenced by 'fo' can be modified, but
variable 'fo' cannot be modified to refer to any other
object [because it is 'final'].
The object referenced by 'co' cannot be modified
[because it is const], but variable 'co' can be
modified to refer to another object.
The object referenced by 'fco' cannot be modified
[because it is const], and variable 'fco' cannot be
modified to refer to another object [because it is
'final'].
METHOD PARAMETERS
The same rules apply to method parameters as to local
variables. That is, a reference parameter declared
'final' cannot be modified, but the object which it
references can be modified. A reference parameter
declared 'const' can be modified, but the object which
it references cannot be modified.
CAST EXPRESSIONS
A reference variable declared 'const' cannot be cast to
its equivalent non-const type. Such casting would
remove the "const-ness" of the object referred to, and
thereby violate const type safety.
Conversely, a reference variable may be implictly cast
to its equivalent const type [by assignment or by
passing it as an argument to a method], which adds
"const-ness" to the resulting reference expression.
There is no syntax for an explicit such cast, since
assigning a const or non-const reference expression to
a const variable does not require an explicit cast.
Consider the following code fragment:class Fooberry
{
const Bar bc;
const Bar enconst[Bar b]
{
bc = b; // Okay
return b; // Okay
}
const Bar addconst[Bar b]
{
bc = [const Bar] b; // Error
return [const Bar] b; // Error
}
}
METHOD RETURN VALUES
Methods may return non-primitive const object types,
which means that the values returned by such methods
cannot be modified [but that references to such objects
can be assigned and passed to other methods].
This implies that the return value of a method declared
as returning a const type can be assigned to only a
const reference variable or passed as an argument to a
method taking a const reference parameter.
Consider the following code fragment:class Foodor
{
Bar getBar[]
{ ... }
const Bar cBar[]
{
return new Bar[]; // Okay
}
void f[]
{
Bar b;
const Bar bc;
b = getBar[]; // Okay
bc = getBar[]; // Okay
b = cBar[]; // Error
bc = cBar[]; // Okay
}
}
CONCLUSION
Adding the 'const' specifier keyword to Java would
bring new forms of type safety to the language, and
simplify the semantics of "read-only" objects.
This bug can be reproduced always.
CUSTOMER WORKAROUND :
Splitting classes into "read-only" and "writable"
interfaces, which is a real pain, especially in a language
without multiple inheritance.
[Review ID: 137795]