Using
different
locking
mechanisms
affects
parallel
programs'
performance
differently,
and
its
impact
on
program
is
difficult
to
assess,
which
hinders
researchers
from
rationally
utilizing
mechanisms.
Moreover,
there
are
few
studies
the
prediction
of
To
address
this
issue,
paper
proposes
a
combination
deep
feedforward
neural
network
(FNN)
Random
Forest
(RF)
method
LockPerf
predict
programs
with
The
predicted
in
execution
time
program.
In
paper,
extracting
static
characteristics
first,
then
sets
variables
such
as
number
threads,
lock
type,
read/write
ratio
by
switch
statement,
finally
runs
collect
multiple
samples
construct
configurable
data
set.
A
total
9
projects
employed
evaluate
effectiveness
Experimental
results
show
that
average
mean
relative
errors
5.47,
standard
95%
confidence
intervals
0.13.
experiments
effectively
predicts
2022 IEEE 46th Annual Computers, Software, and Applications Conference (COMPSAC),
Journal Year:
2023,
Volume and Issue:
unknown, P. 840 - 849
Published: June 1, 2023
In
the
context
of
limited
maintenance
resources,
predicting
severity
code
smells
is
more
practically
useful
than
simply
detecting
them.
Fontana
et
al.
first
empirically
investigated
some
classification
algorithms
and
regression
algorithms,
for
prediction.
Their
results
showed
that
random
forest
decision
tree
performed
well
on
Mean
Absolute
Error
(MAE),
Squared
(MSE),
Spearman
Kendall
rank
correlation
coefficients.
However,
they
did
not
consider
issue
imbalanced
data
distribution
in
dataset,
used
inappropriate
performance
evaluation
metrics.
Therefore,
we
revisit
effectiveness
10
methods
11
methods,
prediction
using
Cumulative
Lift
Chart
(CLC)
Severity@20%
as
primary
metrics
Accuracy
secondary
indicator.
The
show
Gradient
Boosting
Regression
(GBR)
method
performs
best
terms
these
Code
smells
are
code
structures
that
harm
the
software’s
quality.
An
obstacle
to
developing
automatic
detectors
is
available
datasets'
limitations.
Furthermore,
researchers
developed
many
solutions
for
Java
while
neglecting
other
programming
languages.
Recently,
we
created
smell
dataset
C#
by
following
an
annotation
procedure
inspired
established
practices
in
Natural
Language
Processing.
This
paper
evaluates
Machine
Learning
(ML)
detection
approaches
on
our
novel
dataset.
We
consider
two
feature
representations
train
ML
models:
(1)
metrics
and
(2)
CodeT5
embeddings.
study
first
state-of-the-art
neural
source
embedding
C#.
To
prove
effectiveness
of
ML,
multiple
metrics-based
heuristics
as
alternatives.
In
experiments,
best-performing
approach
was
classifier
trained
(F-measure
0.87
Long
Method
0.91
Large
Class
detection).
However,
performance
improvement
over
features
negligible
if
advantages
automatically
inferring
features.
showed
model
exceeds
human
could
be
helpful
developers.
best
knowledge,
this
compare
against
performance.
Authorea (Authorea),
Journal Year:
2023,
Volume and Issue:
unknown
Published: Jan. 10, 2023
Machine
learning-based
code
smell
detection
has
been
demonstrated
to
be
a
valuable
approach
for
improving
software
quality
and
enabling
developers
identify
problematic
patterns
in
code.
However,
previous
researches
have
shown
that
the
datasets
commonly
used
train
these
models
are
heavily
imbalanced.
While
some
recent
studies
explored
use
of
imbalanced
learning
techniques
detection,
they
only
evaluated
limited
number
thus
their
conclusions
about
most
effective
methods
may
biased
inconclusive.
To
thoroughly
evaluate
effect
on
machine
we
examine
31
with
seven
classifiers
build
four
data
sets.
We
employ
evaluation
metrics
assess
performance
Wilcoxon
signed-rank
test
Cliff’s
δ
.
The
results
show
(1)
Not
all
significantly
improve
performance,
but
deep
forest
outperforms
other
(2)
SMOTE
(Synthetic
Minority
Over-sampling
TEchnique)
is
not
technique
resampling
(3)
best-performing
top-3
little
time
cost
detection.
Therefore,
provide
practical
guidelines.
First,
researchers
practitioners
should
select
appropriate
(e.g.,
forest)
ameliorate
class
imbalance
problem.
In
contrast,
blind
application
could
harmful.
Then,
better
than
selected
preprocess
2022 13th International Conference on Computing Communication and Networking Technologies (ICCCNT),
Journal Year:
2023,
Volume and Issue:
unknown
Published: July 6, 2023
Code
smells
are
a
common
problem
in
software
development,
leading
to
decreased
maintainability,
poor
performance,
and
reduced
code
quality.
Addressing
is
crucial
ensuring
that
maintainable,
scalable,
efficient.
To
detect
them,
different
algorithms
used,
including
evolutionary
such
as
Hybrid
Particle
Swarm
Optimization
(HPSOM),
Genetic
Algorithm
(GA),
Parallel
Evolutionary
(PEA),
the
weighted
cockroach
swarm
optimization
algorithm
(WCSO).
WCSO
especially
effective
for
detecting
smells,
it
generates
rules
combine
metrics
thresholds
automatically.
The
main
focus
of
this
paper
using
WCSO.
We
empirically
evaluated
with
other
blob,
spaghetticode,
dataclass,
featureenvy,
functionaldecomposition.
Our
results
prove
outperforms
algorithms,
GA,
HPSOM,
PEA.
Furthermore,
we
found
performs
better
on
range
open-source
applications,
JfreeChart,
GanttProject,
Apache
Ant
7.0,
5.2,
Nutch,
Log4J,
Lucene,
Xerces-J,
Rhino.
By
these
can
take
steps
address
refactoring
make
more
modular
or
reducing
complexity
improve
maintainability
performance.
In
conclusion,
establishes
effectiveness
development
making
reliable
2022 IEEE/ACM 44th International Conference on Software Engineering: Companion Proceedings (ICSE-Companion),
Journal Year:
2023,
Volume and Issue:
unknown, P. 88 - 92
Published: May 1, 2023
Log
recommendation
plays
a
vital
role
in
analyzing
run-time
issues
including
anomaly
detection,
performance
monitoring,
and
security
evaluation.
However,
existing
deeplearning-based
approaches
for
log
suffer
from
insufficient
features
low
F
1
.
To
this
end,
paper
proposes
prototype
called
DeepLog
to
recommend
location
based
on
deep
learning
model.
parses
the
source
code
into
an
abstract
syntax
tree
then
converts
each
method
block
hierarchical
which
extracts
both
semantic
syntactic
features.
By
doing
this,
we
construct
dataset
with
more
than
110K
samples.
employs
double-branched
neural
network
model
locations.
We
evaluate
effectiveness
of
by
answering
four
research
questions.
The
experimental
results
demonstrate
that
it
can
8,725
logs
23
projects
is
28.17%
higher
approaches,
improves
state-of-the-art.
Journal of Software Evolution and Process,
Journal Year:
2024,
Volume and Issue:
36(8)
Published: March 12, 2024
Abstract
The
instanceof
pattern
matching
can
improve
the
code
quality
and
readability
by
removing
redundant
typecasting
simplifying
design
in
different
scenarios.
However,
existing
works
do
not
provide
sufficient
support
for
refactoring
matching.
This
paper
first
identifies
several
cases
that
cannot
be
well
handled
IDEs.
Based
on
these
observations,
we
propose
a
novel
approach
called
ReInstancer
to
refactor
automatically.
conducts
program
analysis
multi‐branch
statements
obtain
variables.
After
analyzing
patterns,
are
optimized
finally
refactored
into
switch
or
expressions.
is
evaluated
20
real‐world
projects
with
more
than
7,700
experimental
results
demonstrate
total
of
3,558
expressions
228
within
10.8
s
average
each
project.
improves
reducing
typecasting,
demonstrating
its
effectiveness.
Code
smells
are
code
structures
that
harm
the
software’s
quality.
An
obstacle
to
developing
automatic
detectors
is
available
datasets'
limitations.
Furthermore,
researchers
developed
many
solutions
for
Java
while
neglecting
other
programming
languages.
Recently,
we
created
smell
dataset
C#
by
following
an
annotation
procedure
inspired
established
practices
in
Natural
Language
Processing.
This
paper
evaluates
Machine
Learning
(ML)
detection
approaches
on
our
novel
dataset.
We
consider
two
feature
representations
train
ML
models:
(1)
metrics
and
(2)
CodeT5
embeddings.
study
first
state-of-the-art
neural
source
embedding
C#.
To
prove
effectiveness
of
ML,
multiple
metrics-based
heuristics
as
alternatives.
In
experiments,
best-performing
approach
was
classifier
trained
(F-measure
0.87
Long
Method
0.91
Large
Class
detection).
However,
performance
improvement
over
features
negligible
if
advantages
automatically
inferring
features.
showed
model
exceeds
human
could
be
helpful
developers.
best
knowledge,
this
compare
against
performance.